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

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/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/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",
+]

mindsdb/integrations/handlers/gong_handler/connection_args.py

@@ -0,0 +1,37 @@
+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.PWD,
+        "description": "Gong API key for authentication.",
+        "secret": True,
+        "required": False,
+        "label": "API Key",
+    },
+    # Basic Authentication with Access Key + Secret Key (Option 2)
+    access_key={
+        "type": ARG_TYPE.STR,
+        "description": "Gong Access Key for basic authentication (if not using OAuth).",
+        "secret": True,
+        "required": False,
+        "label": "Access Key",
+    },
+    secret_key={
+        "type": ARG_TYPE.PWD,
+        "description": "Gong Secret Key for basic authentication (if not using OAuth).",
+        "secret": True,
+        "required": False,
+        "label": "Secret Key",
+    },
+    base_url={
+        "type": ARG_TYPE.STR,
+        "description": "Gong API base URL (optional, defaults to production).",
+        "required": False,
+        "label": "Base URL",
+    },
+)
+
+connection_args_example = OrderedDict(api_key="your_gong_api_key_here", base_url="https://api.gong.io")

mindsdb/integrations/handlers/gong_handler/gong_handler.py

@@ -0,0 +1,164 @@
+import requests
+from typing import Any, Dict
+
+from mindsdb_sql_parser import parse_sql
+
+from mindsdb.integrations.handlers.gong_handler.gong_tables import (
+    GongCallsTable,
+    GongUsersTable,
+    GongAnalyticsTable,
+    GongTranscriptsTable,
+)
+from mindsdb.integrations.libs.api_handler import APIHandler
+from mindsdb.integrations.libs.response import (
+    HandlerResponse as Response,
+    HandlerStatusResponse as StatusResponse,
+    RESPONSE_TYPE,
+)
+from mindsdb.utilities import log
+
+
+logger = log.getLogger(__name__)
+
+
+class GongHandler(APIHandler):
+    """
+    This handler handles the connection and execution of SQL statements on Gong.
+    """
+
+    name = "gong"
+
+    def __init__(self, name: str, connection_data: Dict, **kwargs: Any) -> None:
+        """
+        Initializes the handler.
+
+        Args:
+            name (Text): The name of the handler instance.
+            connection_data (Dict): The connection data required to connect to the Gong API.
+            kwargs: Arbitrary keyword arguments.
+        """
+        super().__init__(name)
+        self.connection_data = connection_data
+        self.kwargs = kwargs
+
+        self.connection = None
+        self.is_connected = False
+        self.base_url = connection_data.get("base_url", "https://api.gong.io")
+
+        # Support both bearer token and access key + secret key
+        self.bearer_token = connection_data.get("api_key")
+        self.access_key = connection_data.get("access_key")
+        self.secret_key = connection_data.get("secret_key")
+
+        # Register core tables
+        self._register_table("calls", GongCallsTable(self))
+        self._register_table("users", GongUsersTable(self))
+        self._register_table("analytics", GongAnalyticsTable(self))
+        self._register_table("transcripts", GongTranscriptsTable(self))
+
+    def connect(self) -> requests.Session:
+        """
+        Establishes a connection to the Gong API.
+
+        Raises:
+            ValueError: If the required connection parameters are not provided.
+            Exception: If a connection error occurs.
+
+        Returns:
+            requests.Session: A session object for making API requests.
+        """
+        if self.is_connected is True:
+            return self.connection
+
+        if self.access_key and self.secret_key:
+            auth_method = "basic"
+        elif self.bearer_token:
+            auth_method = "bearer"
+        else:
+            raise ValueError("Either bearer_token or (access_key + secret_key) is required to connect to Gong API.")
+
+        try:
+            self.connection = requests.Session()
+
+            if auth_method == "basic":
+                # Basic authentication with access key + secret key
+                self.connection.auth = (self.access_key, self.secret_key)
+                self.connection.headers.update({"Content-Type": "application/json", "Accept": "application/json"})
+            else:
+                # Bearer token authentication
+                self.connection.headers.update(
+                    {
+                        "Authorization": f"Bearer {self.bearer_token}",
+                        "Content-Type": "application/json",
+                        "Accept": "application/json",
+                    }
+                )
+
+            test_response = self.connection.get(f"{self.base_url}/v2/users")
+            test_response.raise_for_status()
+
+            self.is_connected = True
+            return self.connection
+
+        except Exception as e:
+            self.is_connected = False
+            logger.error(f"Error connecting to Gong API: {e}")
+            raise
+
+    def check_connection(self) -> StatusResponse:
+        """
+        Checks the status of the connection to the Gong API.
+
+        Returns:
+            StatusResponse: An object containing the success status and an error message if an error occurs.
+        """
+        response = StatusResponse(False)
+
+        try:
+            self.connect()
+            # Test the connection by making a simple API call
+            test_response = self.connection.get(f"{self.base_url}/v2/users")
+            test_response.raise_for_status()
+            response.success = True
+        except Exception as e:
+            logger.error(f"Connection check to Gong failed: {e}")
+            response.error_message = str(e)
+
+        self.is_connected = response.success
+        return response
+
+    def native_query(self, query: str) -> Response:
+        """
+        Executes a native query on Gong and returns the result.
+
+        Args:
+            query (Text): The SQL query to be executed.
+
+        Returns:
+            Response: A response object containing the result of the query or an error message.
+        """
+        try:
+            ast = parse_sql(query)
+            return self.query(ast)
+        except Exception as e:
+            logger.error(f"Error running query: {query} on Gong: {e}")
+            return Response(RESPONSE_TYPE.ERROR, error_code=0, error_message=str(e))
+
+    def call_gong_api(self, endpoint: str, params: Dict = None) -> Dict:
+        """
+        Makes a call to the Gong API.
+
+        Args:
+            endpoint (str): The API endpoint to call.
+            params (Dict): Query parameters for the API call.
+
+        Returns:
+            Dict: The API response.
+        """
+        if not self.is_connected:
+            self.connect()
+
+        url = f"{self.base_url}{endpoint}"
+        response = self.connection.get(url, params=params)
+        response.raise_for_status()
+        return response.json()