MindsDB 25.7.3.0__py3-none-any.whl → 25.8.2.0__py3-none-any.whl

mindsdb/api/http/namespaces/tree.py

@@ -9,97 +9,105 @@ from mindsdb.api.http.namespaces.configs.tree import ns_conf
 from mindsdb.metrics.metrics import api_endpoint_metrics
 
 
-@ns_conf.route('/')
+@ns_conf.route("/")
 class GetRoot(Resource):
-    @ns_conf.doc('get_tree_root')
-    @api_endpoint_metrics('GET', '/tree')
+    @ns_conf.doc("get_tree_root")
+    @api_endpoint_metrics("GET", "/tree")
     def get(self):
         databases = ca.database_controller.get_list()
-        result = [{
-            'name': x['name'],
-            'class': 'db',
-            'type': x['type'],
-            'engine': x['engine'],
-            'deletable': x['deletable'],
-            'visible': x['visible']
-        } for x in databases]
+        result = [
+            {
+                "name": x["name"],
+                "class": "db",
+                "type": x["type"],
+                "engine": x["engine"],
+                "deletable": x["deletable"],
+                "visible": x["visible"],
+            }
+            for x in databases
+        ]
         return result
 
 
-@ns_conf.route('/<db_name>')
-@ns_conf.param('db_name', "Name of the database")
+@ns_conf.route("/<db_name>")
+@ns_conf.param("db_name", "Name of the database")
 class GetLeaf(Resource):
-    @ns_conf.doc('get_tree_leaf')
-    @api_endpoint_metrics('GET', '/tree/database')
+    @ns_conf.doc("get_tree_leaf")
+    @api_endpoint_metrics("GET", "/tree/database")
     def get(self, db_name):
-        with_schemas = request.args.get('all_schemas')
+        with_schemas = request.args.get("all_schemas")
         if isinstance(with_schemas, str):
-            with_schemas = with_schemas.lower() in ('1', 'true')
+            with_schemas = with_schemas.lower() in ("1", "true")
         else:
             with_schemas = False
         db_name = db_name.lower()
         databases = ca.database_controller.get_dict()
         if db_name not in databases:
-            return http_error(
-                400,
-                "Error",
-                f"There is no element with name '{db_name}'"
-            )
+            return http_error(400, "Error", f"There is no element with name '{db_name}'")
         db = databases[db_name]
-        if db['type'] == 'project':
+        if db["type"] == "project":
             project = ca.database_controller.get_project(db_name)
             tables = project.get_tables()
-            tables = [{
-                'name': key,
-                'schema': None,
-                'class': 'table',
-                'type': val['type'],
-                'engine': val.get('engine'),
-                'deletable': val.get('deletable')
-            } for key, val in tables.items()]
-        elif db['type'] == 'data':
+            tables = [
+                {
+                    "name": key,
+                    "schema": None,
+                    "class": "table",
+                    "type": val["type"],
+                    "engine": val.get("engine"),
+                    "deletable": val.get("deletable"),
+                }
+                for key, val in tables.items()
+            ]
+
+            jobs = ca.jobs_controller.get_list(db_name)
+            tables = tables + [
+                {"name": job["name"], "schema": None, "class": "job", "type": "job", "engine": "job", "deletable": True}
+                for job in jobs
+            ]
+        elif db["type"] == "data":
             handler = ca.integration_controller.get_data_handler(db_name)
-            if 'all' in inspect.signature(handler.get_tables).parameters:
+            if "all" in inspect.signature(handler.get_tables).parameters:
                 response = handler.get_tables(all=with_schemas)
             else:
                 response = handler.get_tables()
-            if response.type != 'table':
+            if response.type != "table":
                 return []
-            table_types = {
-                'BASE TABLE': 'table',
-                'VIEW': 'view'
-            }
-            tables = response.data_frame.to_dict(orient='records')
+            table_types = {"BASE TABLE": "table", "VIEW": "view"}
+            tables = response.data_frame.to_dict(orient="records")
 
             schemas = defaultdict(list)
 
             for table_meta in tables:
                 table_meta = {key.lower(): val for key, val in table_meta.items()}
-                schama = table_meta.get('table_schema')
-                schemas[schama].append({
-                    'name': table_meta['table_name'],
-                    'class': 'table',
-                    'type': table_types.get(table_meta.get('table_type')),
-                    'engine': None,
-                    'deletable': False
-                })
+                schama = table_meta.get("table_schema")
+                schemas[schama].append(
+                    {
+                        "name": table_meta["table_name"],
+                        "class": "table",
+                        "type": table_types.get(table_meta.get("table_type")),
+                        "engine": None,
+                        "deletable": False,
+                    }
+                )
             if len(schemas) == 1 and list(schemas.keys())[0] is None:
                 tables = schemas[None]
             else:
-                tables = [{
-                    'name': key,
-                    'class': 'schema',
-                    'deletable': False,
-                    'children': val
-                } for key, val in schemas.items()]
-        elif db['type'] == 'system':
+                tables = [
+                    {"name": key, "class": "schema", "deletable": False, "children": val}
+                    for key, val in schemas.items()
+                ]
+        elif db["type"] == "system":
             system_db = ca.database_controller.get_system_db(db_name)
             tables = system_db.get_tree_tables()
-            tables = [{
-                'name': table.name,
-                'class': table.kind,
-                'type': 'system view',
-                'engine': None,
-                'deletable': table.deletable,
-            } for table in tables.values()]
+            tables = [
+                {
+                    "name": table.name,
+                    "class": table.kind,
+                    "type": "system view",
+                    "engine": None,
+                    "deletable": table.deletable,
+                }
+                for table in tables.values()
+            ]
         return tables

mindsdb/api/http/namespaces/views.py

@@ -10,143 +10,127 @@ from mindsdb.metrics.metrics import api_endpoint_metrics
 from mindsdb.utilities.exception import EntityNotExistsError
 
 
-@ns_conf.route('/<project_name>/views')
+@ns_conf.route("/<project_name>/views")
 class ViewsList(Resource):
-    @ns_conf.doc('list_views')
-    @api_endpoint_metrics('GET', '/views')
+    @ns_conf.doc("list_views")
+    @api_endpoint_metrics("GET", "/views")
     def get(self, project_name):
-        '''List all views'''
+        """List all views"""
         session = SessionController()
         try:
             project = session.database_controller.get_project(project_name)
         except EntityNotExistsError:
-            return http_error(
-                HTTPStatus.NOT_FOUND,
-                'Project not found',
-                f'Project name {project_name} does not exist'
-            )
+            return http_error(HTTPStatus.NOT_FOUND, "Project not found", f"Project name {project_name} does not exist")
 
         all_views = project.get_views()
         all_view_objs = []
         # Only want to return relevant fields to the user.
         for view in all_views:
-            all_view_objs.append({
-                'id': view['metadata']['id'],
-                'name': view['name'],
-                'query': view['query']
-            })
+            all_view_objs.append({"id": view["metadata"]["id"], "name": view["name"], "query": view["query"]})
         return all_view_objs
 
-    @ns_conf.doc('create_view')
-    @api_endpoint_metrics('POST', '/views')
+    @ns_conf.doc("create_view")
+    @api_endpoint_metrics("POST", "/views")
     def post(self, project_name):
-        '''Create a new view'''
-        if 'view' not in request.json:
-            return http_error(HTTPStatus.BAD_REQUEST, 'Wrong argument', 'Must provide "view" parameter in POST body')
+        """Create a new view"""
+        if "view" not in request.json:
+            return http_error(HTTPStatus.BAD_REQUEST, "Wrong argument", 'Must provide "view" parameter in POST body')
         session = SessionController()
-        view_obj = request.json['view']
-        if 'name' not in view_obj:
-            return http_error(HTTPStatus.BAD_REQUEST, 'Wrong argument', 'Missing "name" field for view')
-        if 'query' not in view_obj:
-            return http_error(HTTPStatus.BAD_REQUEST, 'Wrong argument', 'Missing "query" field for view')
-        name = view_obj['name']
-        query = view_obj['query']
+        view_obj = request.json["view"]
+        if "name" not in view_obj:
+            return http_error(HTTPStatus.BAD_REQUEST, "Wrong argument", 'Missing "name" field for view')
+        if "query" not in view_obj:
+            return http_error(HTTPStatus.BAD_REQUEST, "Wrong argument", 'Missing "query" field for view')
+        name = view_obj["name"]
+        query = view_obj["query"]
 
         try:
             project = session.database_controller.get_project(project_name)
         except EntityNotExistsError:
-            return http_error(HTTPStatus.NOT_FOUND, 'Not found', f'Project name {project_name} does not exist')
+            return http_error(HTTPStatus.NOT_FOUND, "Not found", f"Project name {project_name} does not exist")
 
         if project.get_view(name) is not None:
-            return http_error(HTTPStatus.CONFLICT, 'Name conflict', f'View with name {name} already exists.')
+            return http_error(HTTPStatus.CONFLICT, "Name conflict", f"View with name {name} already exists.")
 
-        project.create_view(name, query)
+        project.create_view(name, query, session)
         created_view = project.get_view(name)
         # Only want to return relevant fields to the user.
         return {
-            'id': created_view['metadata']['id'],
-            'name': created_view['name'],
-            'query': created_view['query']
+            "id": created_view["metadata"]["id"],
+            "name": created_view["name"],
+            "query": created_view["query"],
         }, HTTPStatus.CREATED
 
 
-@ns_conf.route('/<project_name>/views/<view_name>')
-@ns_conf.param('project_name', 'Name of the project')
-@ns_conf.param('view_name', 'Name of the view')
+@ns_conf.route("/<project_name>/views/<view_name>")
+@ns_conf.param("project_name", "Name of the project")
+@ns_conf.param("view_name", "Name of the view")
 class ViewResource(Resource):
-    @ns_conf.doc('get_view')
-    @api_endpoint_metrics('GET', '/views/view')
+    @ns_conf.doc("get_view")
+    @api_endpoint_metrics("GET", "/views/view")
     def get(self, project_name, view_name):
-        '''Get a view by name'''
+        """Get a view by name"""
         session = SessionController()
         try:
             project = session.database_controller.get_project(project_name)
         except EntityNotExistsError:
-            return http_error(HTTPStatus.NOT_FOUND, 'Project not found', f'Project name {project_name} does not exist')
+            return http_error(HTTPStatus.NOT_FOUND, "Project not found", f"Project name {project_name} does not exist")
 
         view = project.get_view(view_name)
         if view is None:
-            return http_error(HTTPStatus.NOT_FOUND, 'View not found', f'View with name {view_name} does not exist')
+            return http_error(HTTPStatus.NOT_FOUND, "View not found", f"View with name {view_name} does not exist")
 
         # Only want to return relevant fields to the user.
-        return {
-            'id': view['metadata']['id'],
-            'name': view['name'],
-            'query': view['query']
-        }
+        return {"id": view["metadata"]["id"], "name": view["name"], "query": view["query"]}
 
-    @ns_conf.doc('update_view')
-    @api_endpoint_metrics('PUT', '/views/view')
+    @ns_conf.doc("update_view")
+    @api_endpoint_metrics("PUT", "/views/view")
     def put(self, project_name, view_name):
-        '''Updates or creates a view'''
-        if 'view' not in request.json:
-            return http_error(HTTPStatus.BAD_REQUEST, 'Wrong argument', 'Must provide "view" parameter in PUT body')
-        request_view = request.json['view']
+        """Updates or creates a view"""
+        if "view" not in request.json:
+            return http_error(HTTPStatus.BAD_REQUEST, "Wrong argument", 'Must provide "view" parameter in PUT body')
+        request_view = request.json["view"]
         session = SessionController()
         try:
             project = session.database_controller.get_project(project_name)
         except EntityNotExistsError:
-            return http_error(HTTPStatus.NOT_FOUND, 'Project not found', f'Project name {project_name} does not exist')
+            return http_error(HTTPStatus.NOT_FOUND, "Project not found", f"Project name {project_name} does not exist")
 
         existing_view = project.get_view(view_name)
         if existing_view is None:
             # Create
-            if 'query' not in request_view:
-                return http_error(HTTPStatus.BAD_REQUEST, 'Wrong argument', 'Missing "query" field for new view')
-            project.create_view(view_name, request_view['query'])
+            if "query" not in request_view:
+                return http_error(HTTPStatus.BAD_REQUEST, "Wrong argument", 'Missing "query" field for new view')
+            project.create_view(view_name, request_view["query"], session)
             created_view = project.get_view(view_name)
             # Only want to return relevant fields to the user.
             return {
-                'id': created_view['metadata']['id'],
-                'name': created_view['name'],
-                'query': created_view['query']
+                "id": created_view["metadata"]["id"],
+                "name": created_view["name"],
+                "query": created_view["query"],
             }, HTTPStatus.CREATED
 
-        new_query = existing_view['query']
-        if 'query' in request_view:
-            new_query = request_view['query']
+        new_query = existing_view["query"]
+        if "query" in request_view:
+            new_query = request_view["query"]
             project.update_view(view_name, new_query)
 
         existing_view = project.get_view(view_name)
         # Only want to return relevant fields to the user.
-        return {
-            'id': existing_view['metadata']['id'],
-            'name': existing_view['name'],
-            'query': existing_view['query']
-        }
+        return {"id": existing_view["metadata"]["id"], "name": existing_view["name"], "query": existing_view["query"]}
 
-    @ns_conf.doc('delete_view')
-    @api_endpoint_metrics('DELETE', '/views/view')
+    @ns_conf.doc("delete_view")
+    @api_endpoint_metrics("DELETE", "/views/view")
     def delete(self, project_name, view_name):
-        '''Deletes a view by name'''
+        """Deletes a view by name"""
         session = SessionController()
         try:
             project = session.database_controller.get_project(project_name)
         except EntityNotExistsError:
-            return http_error(HTTPStatus.NOT_FOUND, 'Project not found', f'Project name {project_name} does not exist')
+            return http_error(HTTPStatus.NOT_FOUND, "Project not found", f"Project name {project_name} does not exist")
 
         if project.get_view(view_name) is None:
-            return http_error(HTTPStatus.NOT_FOUND, 'View not found', f'View with name {view_name} does not exist')
+            return http_error(HTTPStatus.NOT_FOUND, "View not found", f"View with name {view_name} does not exist")
 
         project.delete_view(view_name)
-        return '', HTTPStatus.NO_CONTENT
+        return "", HTTPStatus.NO_CONTENT

mindsdb/api/mcp/start.py

@@ -15,6 +15,7 @@ from starlette.responses import Response
 from mindsdb.api.mysql.mysql_proxy.classes.fake_mysql_proxy import FakeMysqlProxy
 from mindsdb.api.executor.data_types.response_type import RESPONSE_TYPE as SQL_RESPONSE_TYPE
 from mindsdb.utilities import log
+from mindsdb.utilities.log import get_uvicorn_logging_config
 from mindsdb.utilities.config import Config
 from mindsdb.interfaces.storage import db
 
@@ -173,6 +174,7 @@ async def run_sse_async() -> None:
         host=mcp.settings.host,
         port=mcp.settings.port,
         log_level=mcp.settings.log_level.lower(),
+        log_config=get_uvicorn_logging_config("uvicorn_mcp"),
     )
     server = uvicorn.Server(config)
     await server.serve()

mindsdb/api/mysql/mysql_proxy/utilities/dump.py

@@ -118,8 +118,9 @@ def _dump_str(var: Any) -> str | None:
             return json_encoder.encode(var)
         except Exception:
             return str(var)
-    if isinstance(var, list) is False and pd.isna(var):
-        # pd.isna returns array of bools for list, so we need to check if it is not a list
+    # pd.isna returns array of bools for list
+    # and the truth value of a numpy array is ambiguous
+    if isinstance(var, (list, np.ndarray)) is False and pd.isna(var):
         return None
     return str(var)
 

mindsdb/integrations/handlers/autogluon_handler/requirements.txt

@@ -1,2 +1,2 @@
 autogluon
-type_infer==0.0.20
+type_infer==0.0.23

mindsdb/integrations/handlers/autosklearn_handler/requirements.txt

@@ -1,2 +1,2 @@
 auto-sklearn
-type_infer==0.0.20
+type_infer==0.0.23

mindsdb/integrations/handlers/bigquery_handler/bigquery_handler.py

@@ -1,8 +1,10 @@
-from google.cloud.bigquery import Client, QueryJobConfig
-from google.api_core.exceptions import BadRequest
+import json
+from typing import Any, Dict, Optional, Text
+
+from google.cloud.bigquery import Client, QueryJobConfig, DEFAULT_RETRY
+from google.api_core.exceptions import BadRequest, NotFound
 import pandas as pd
 from sqlalchemy_bigquery.base import BigQueryDialect
-from typing import Any, Dict, Optional, Text
 
 from mindsdb.utilities import log
 from mindsdb_sql_parser.ast.base import ASTNode
@@ -54,9 +56,22 @@ class BigQueryHandler(MetaDatabaseHandler):
         if not all(key in self.connection_data for key in ["project_id", "dataset"]):
             raise ValueError("Required parameters (project_id, dataset) must be provided.")
 
+        service_account_json = self.connection_data.get("service_account_json")
+        if isinstance(service_account_json, str):
+            # GUI send it as str
+            try:
+                service_account_json = json.loads(service_account_json)
+            except json.decoder.JSONDecodeError:
+                raise ValueError("'service_account_json' is not valid JSON")
+        if isinstance(service_account_json, dict) and isinstance(service_account_json.get("private_key"), str):
+            # some editors may escape new line symbol, also replace windows-like newlines
+            service_account_json["private_key"] = (
+                service_account_json["private_key"].replace("\\n", "\n").replace("\r\n", "\n")
+            )
+
         google_sa_oauth2_manager = GoogleServiceAccountOAuth2Manager(
             credentials_file=self.connection_data.get("service_account_keys"),
-            credentials_json=self.connection_data.get("service_account_json"),
+            credentials_json=service_account_json,
         )
         credentials = google_sa_oauth2_manager.get_oauth2_credentials()
 
@@ -85,7 +100,7 @@ class BigQueryHandler(MetaDatabaseHandler):
 
         try:
             connection = self.connect()
-            connection.query("SELECT 1;")
+            connection.query("SELECT 1;", timeout=10, retry=DEFAULT_RETRY.with_deadline(10))
 
             # Check if the dataset exists
             connection.get_dataset(self.connection_data["dataset"])
@@ -94,6 +109,11 @@ class BigQueryHandler(MetaDatabaseHandler):
         except (BadRequest, ValueError) as e:
             logger.error(f"Error connecting to BigQuery {self.connection_data['project_id']}, {e}!")
             response.error_message = e
+        except NotFound:
+            response.error_message = (
+                f"Error connecting to BigQuery {self.connection_data['project_id']}: "
+                f"dataset '{self.connection_data['dataset']}' not found"
+            )
 
         if response.success is False and self.is_connected is True:
             self.is_connected = False

mindsdb/integrations/handlers/chromadb_handler/chromadb_handler.py

@@ -59,6 +59,7 @@ class ChromaDBHandler(VectorStoreHandler):
         self._client = None
         self.persist_directory = None
         self.is_connected = False
+        self._use_handler_storage = False
 
         config = self.validate_connection_parameters(name, **kwargs)
 
@@ -72,8 +73,6 @@ class ChromaDBHandler(VectorStoreHandler):
             "hnsw:space": config.distance,
         }
 
-        self._use_handler_storage = False
-
         self.connect()
 
     def validate_connection_parameters(self, name, **kwargs):
@@ -395,7 +394,7 @@ class ChromaDBHandler(VectorStoreHandler):
 
         return df
 
-    def insert(self, collection_name: str, df: pd.DataFrame):
+    def insert(self, collection_name: str, df: pd.DataFrame) -> Response:
         """
         Insert/Upsert data into ChromaDB collection.
         If records with same IDs exist, they will be updated.
@@ -433,6 +432,7 @@ class ChromaDBHandler(VectorStoreHandler):
         except Exception as e:
             logger.error(f"Error during upsert operation: {str(e)}")
             raise Exception(f"Failed to insert/update data: {str(e)}")
+        return Response(RESPONSE_TYPE.OK, affected_rows=len(df))
 
     def upsert(self, table_name: str, data: pd.DataFrame):
         """

mindsdb/integrations/handlers/db2_handler/db2_handler.py

@@ -59,16 +59,20 @@ class DB2Handler(DatabaseHandler):
             return self.connection
 
         # Mandatory connection parameters.
-        if not all(key in self.connection_data for key in ['host', 'user', 'password', 'database']):
-            raise ValueError('Required parameters (host, user, password, database) must be provided.')
-
-        connection_string = f"DRIVER={'IBM DB2 ODBC DRIVER'};DATABASE={self.connection_data['database']};HOST={self.connection_data['host']};PROTOCOL=TCPIP;UID={self.connection_data['user']};PWD={self.connection_data['password']};"
-
-        # Optional connection parameters.
-        if 'port' in self.connection_data:
-            connection_string += f"PORT={self.connection_data['port']};"
-
-        if 'schema' in self.connection_data:
+        if not all(key in self.connection_data for key in ["host", "user", "password", "database"]):
+            raise ValueError("Required parameters (host, user, password, database) must be provided.")
+        cloud = "databases.appdomain.cloud" in self.connection_data["host"]
+        if cloud:
+            connection_string = f"DATABASE={self.connection_data['database']};HOSTNAME={self.connection_data['host']};PORT={self.connection_data['port']};PROTOCOL=TCPIP;UID={self.connection_data['user']};PWD={self.connection_data['password']};SECURITY=SSL;"
+            connection_string += "SSLSERVERCERTIFICATE=;"
+        else:
+            connection_string = f"DRIVER={'IBM DB2 ODBC DRIVER'};DATABASE={self.connection_data['database']};HOST={self.connection_data['host']};PROTOCOL=TCPIP;UID={self.connection_data['user']};PWD={self.connection_data['password']};"
+
+            # Optional connection parameters.
+            if "port" in self.connection_data:
+                connection_string += f"PORT={self.connection_data['port']};"
+
+        if "schema" in self.connection_data:
             connection_string += f"CURRENTSCHEMA={self.connection_data['schema']};"
 
         try:
@@ -106,10 +110,10 @@ class DB2Handler(DatabaseHandler):
             self.connect()
             response.success = True
         except (OperationalError, ValueError) as known_error:
-            logger.error(f'Connection check to IBM Db2 failed, {known_error}!')
+            logger.error(f"Connection check to IBM Db2 failed, {known_error}!")
             response.error_message = str(known_error)
         except Exception as unknown_error:
-            logger.error(f'Connection check to IBM Db2 failed due to an unknown error, {unknown_error}!')
+            logger.error(f"Connection check to IBM Db2 failed due to an unknown error, {unknown_error}!")
             response.error_message = str(unknown_error)
 
         if response.success and need_to_close:
@@ -141,9 +145,7 @@ class DB2Handler(DatabaseHandler):
                     result = cur.fetchall()
                     response = Response(
                         RESPONSE_TYPE.TABLE,
-                        data_frame=pd.DataFrame(
-                            result, columns=[x[0] for x in cur.description]
-                        ),
+                        data_frame=pd.DataFrame(result, columns=[x[0] for x in cur.description]),
                     )
                 else:
                     response = Response(RESPONSE_TYPE.OK)
@@ -198,10 +200,7 @@ class DB2Handler(DatabaseHandler):
                 }
             )
 
-        response = Response(
-            RESPONSE_TYPE.TABLE,
-            data_frame=pd.DataFrame(tables)
-        )
+        response = Response(RESPONSE_TYPE.TABLE, data_frame=pd.DataFrame(tables))
 
         return response
 
@@ -227,9 +226,6 @@ class DB2Handler(DatabaseHandler):
 
         columns = [column["COLUMN_NAME"] for column in result]
 
-        response = Response(
-            RESPONSE_TYPE.TABLE,
-            data_frame=pd.DataFrame(columns, columns=["COLUMN_NAME"])
-        )
+        response = Response(RESPONSE_TYPE.TABLE, data_frame=pd.DataFrame(columns, columns=["COLUMN_NAME"]))
 
         return response

mindsdb/integrations/handlers/flaml_handler/requirements.txt

@@ -1,2 +1,2 @@
 flaml<=1.2.3
-type_infer==0.0.20
+type_infer==0.0.23

mindsdb/integrations/handlers/gong_handler/__about__.py

@@ -0,0 +1,2 @@
+__version__ = "0.0.1"
+__description__ = "Gong conversation intelligence platform handler for MindsDB"

mindsdb/integrations/handlers/gong_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 .gong_handler import GongHandler as Handler
+
+    import_error = None
+except Exception as e:
+    Handler = None
+    import_error = e
+
+title = "Gong"
+name = "gong"
+type = HANDLER_TYPE.DATA
+icon_path = "icon.svg"
+
+__all__ = [
+    "Handler",
+    "version",
+    "name",
+    "type",
+    "title",
+    "description",
+    "import_error",
+    "icon_path",
+    "connection_args_example",
+    "connection_args",
+]