MindsDB 25.3.4.0__py3-none-any.whl → 25.3.4.1__py3-none-any.whl

mindsdb/__about__.py

@@ -1,10 +1,10 @@
 __title__ = 'MindsDB'
 __package_name__ = 'mindsdb'
-__version__ = '25.3.4.0'
+__version__ = '25.3.4.1'
 __description__ = "MindsDB's AI SQL Server enables developers to build AI tools that need access to real-time data to perform their tasks"
 __email__ = "jorge@mindsdb.com"
 __author__ = 'MindsDB Inc'
 __github__ = 'https://github.com/mindsdb/mindsdb'
 __pypi__ = 'https://pypi.org/project/mindsdb/'
-__license__ = 'SSPL v1'
+__license__ = 'Elastic License 2.0'
 __copyright__ = 'Copyright(c) 2018 MindsDB, Inc'

mindsdb/integrations/handlers/confluence_handler/confluence_api_client.py

@@ -0,0 +1,164 @@
+from typing import List
+
+import requests
+
+
+class ConfluenceAPIClient:
+    def __init__(self, url: str, username: str, password: str):
+        self.url = url
+        self.username = username
+        self.password = password
+        self.session = requests.Session()
+        self.session.auth = (self.username, self.password)
+        self.session.headers.update({"Accept": "application/json"})
+
+    def get_spaces(
+        self,
+        ids: List[int] = None,
+        keys: List[str] = None,
+        space_type: str = None,
+        status: str = None,
+        sort_condition: str = None,
+        limit: int = None,
+    ):
+        url = f"{self.url}/wiki/api/v2/spaces"
+        params = {
+            "description-format": "view",
+        }
+        if ids:
+            params["ids"] = ids
+        if keys:
+            params["keys"] = keys
+        if space_type:
+            params["type"] = space_type
+        if status:
+            params["status"] = status
+        if sort_condition:
+            params["sort"] = sort_condition
+        if limit:
+            params["limit"] = limit
+
+        return self._paginate(url, params)
+
+    def get_pages(
+        self,
+        page_ids: List[int] = None,
+        space_ids: List[int] = None,
+        statuses: List[str] = None,
+        title: str = None,
+        sort_condition: str = None,
+        limit: int = None,
+    ) -> List[dict]:
+        url = f"{self.url}/wiki/api/v2/pages"
+        params = {
+            "body-format": "storage",
+        }
+        if page_ids:
+            params["id"] = page_ids
+        if space_ids:
+            params["space-id"] = space_ids
+        if statuses:
+            params["status"] = statuses
+        if title:
+            params["title"] = title
+        if sort_condition:
+            params["sort"] = sort_condition
+        if limit:
+            params["limit"] = limit
+
+        return self._paginate(url, params)
+
+    def get_blogposts(
+        self,
+        post_ids: List[int] = None,
+        space_ids: List[str] = None,
+        statuses: List[str] = None,
+        title: str = None,
+        sort_condition: str = None,
+        limit: int = None,
+    ) -> List[dict]:
+        url = f"{self.url}/wiki/api/v2/blogposts"
+        params = {
+            "body-format": "storage",
+        }
+        if post_ids:
+            params["id"] = post_ids
+        if space_ids:
+            params["space-id"] = space_ids
+        if statuses:
+            params["status"] = statuses
+        if title:
+            params["title"] = title
+        if sort_condition:
+            params["sort"] = sort_condition
+        if limit:
+            params["limit"] = limit
+
+        return self._paginate(url, params)
+
+    def get_whiteboard_by_id(self, whiteboard_id: int) -> dict:
+        url = f"{self.url}/wiki/api/v2/whiteboards/{whiteboard_id}"
+
+        return self._make_request("GET", url)
+
+    def get_database_by_id(self, database_id: int) -> dict:
+        url = f"{self.url}/wiki/api/v2/databases/{database_id}"
+
+        return self._make_request("GET", url)
+
+    def get_tasks(
+        self,
+        task_ids: List[int] = None,
+        space_ids: List[str] = None,
+        page_ids: List[str] = None,
+        blogpost_ids: List[str] = None,
+        created_by_ids: List[str] = None,
+        assigned_to_ids: List[str] = None,
+        completed_by_ids: List[str] = None,
+        status: str = None,
+        limit: int = None,
+    ) -> List[dict]:
+        url = f"{self.url}/wiki/api/v2/tasks"
+        params = {
+            "body-format": "storage",
+        }
+        if task_ids:
+            params["id"] = task_ids
+        if space_ids:
+            params["space-id"] = space_ids
+        if page_ids:
+            params["page-id"] = page_ids
+        if blogpost_ids:
+            params["blogpost-id"] = blogpost_ids
+        if created_by_ids:
+            params["created-by"] = created_by_ids
+        if assigned_to_ids:
+            params["assigned-to"] = assigned_to_ids
+        if completed_by_ids:
+            params["completed-by"] = completed_by_ids
+        if status:
+            params["status"] = status
+        if limit:
+            params["limit"] = limit
+
+        return self._paginate(url, params)
+
+    def _paginate(self, url: str, params: dict = None) -> List[dict]:
+        results = []
+        response = self._make_request("GET", url, params)
+        results.extend(response["results"])
+
+        while response["_links"].get("next"):
+            params["cursor"] = response["_links"].get("next")
+            response = self._make_request("GET", url, params)
+            results.extend(response["results"])
+
+        return results
+
+    def _make_request(self, method: str, url: str, params: dict = None, data: dict = None) -> dict:
+        response = self.session.request(method, url, params=params, json=data)
+
+        if response.status_code != 200:
+            raise Exception(f"Request failed with status code {response.status_code}: {response.text}")
+
+        return response.json()

mindsdb/integrations/handlers/confluence_handler/confluence_handler.py

@@ -1,83 +1,92 @@
-from typing import Optional, Union
+from typing import Any, Dict
 
-import requests
-from atlassian import Confluence
-from mindsdb_sql_parser import parse_sql
-
-from mindsdb.integrations.handlers.confluence_handler.confluence_table import (
+from mindsdb.integrations.handlers.confluence_handler.confluence_api_client import ConfluenceAPIClient
+from mindsdb.integrations.handlers.confluence_handler.confluence_tables import (
+    ConfluenceBlogPostsTable,
+    ConfluenceDatabasesTable,
     ConfluencePagesTable,
+    ConfluenceSpacesTable,
+    ConfluenceTasksTable,
+    ConfluenceWhiteboardsTable,
 )
 from mindsdb.integrations.libs.api_handler import APIHandler
 from mindsdb.integrations.libs.response import (
     HandlerStatusResponse as StatusResponse,
 )
-from mindsdb_sql_parser import parse_sql
 from mindsdb.utilities import log
 
-from atlassian import Confluence
-from typing import Optional
-import requests
 
 logger = log.getLogger(__name__)
 
+
 class ConfluenceHandler(APIHandler):
-    """Confluence handler implementation"""
-
-    def __init__(self, name=None, **kwargs):
-        """Initialize the Confluence handler.
-        Parameters
-        ----------
-        name : str
-            name of a handler instance
-        """
-        super().__init__(name)
+    """
+    This handler handles the connection and execution of SQL statements on Confluence.
+    """
+
+    name = "confluence"
 
-        connection_data = kwargs.get("connection_data", {})
+    def __init__(self, name: str, connection_data: Dict, **kwargs: Any) -> None:
+        """
+        Initializes the handler.
 
-        self.parser = parse_sql
-        self.dialect = 'confluence'
+        Args:
+            name (str): The name of the handler instance.
+            connection_data (Dict): The connection data required to connect to the Confluence API.
+            kwargs: Arbitrary keyword arguments.
+        """
+        super().__init__(name)
         self.connection_data = connection_data
         self.kwargs = kwargs
+
         self.connection = None
         self.is_connected = False
+        self.thread_safe = True
 
-        confluence_pages_data = ConfluencePagesTable(self)
-        self._register_table("pages", confluence_pages_data)
+        self._register_table("spaces", ConfluenceSpacesTable(self))
+        self._register_table("pages", ConfluencePagesTable(self))
+        self._register_table("blogposts", ConfluenceBlogPostsTable(self))
+        self._register_table("whiteboards", ConfluenceWhiteboardsTable(self))
+        self._register_table("databases", ConfluenceDatabasesTable(self))
+        self._register_table("tasks", ConfluenceTasksTable(self))
 
-    def connect(self):
-        """Set up the connection required by the handler.
-        Returns
-        -------
-        StatusResponse
-            connection object
+    def connect(self) -> ConfluenceAPIClient:
+        """
+        Establishes a connection to the Confluence API.
+
+        Raises:
+            ValueError: If the required connection parameters are not provided.
+
+        Returns:
+            atlassian.confluence.Confluence: A connection object to the Confluence API.
         """
         if self.is_connected is True:
             return self.connection
-        
-        if not all(key in self.connection_data and self.connection_data.get(key) for key in ['url', 'username', 'password']):
-            raise ValueError('Required parameters (url, username, password) must be provided and should not be empty.')
-        
-        conf = Confluence(
-            url=self.connection_data.get('url'),
+
+        if not all(key in self.connection_data and self.connection_data.get(key) for key in ['api_base', 'username', 'password']):
+            raise ValueError('Required parameters (api_base, username, password) must be provided and should not be empty.')
+
+        self.connection = ConfluenceAPIClient(
+            url=self.connection_data.get('api_base'),
             username=self.connection_data.get('username'),
             password=self.connection_data.get('password'),
         )
-        self.connection = conf
+
         self.is_connected = True
         return self.connection
 
     def check_connection(self) -> StatusResponse:
-        """Check connection to the handler.
-        Returns
-        -------
-        StatusResponse
-            Status confirmation
+        """
+        Checks the status of the connection to the Confluence API.
+
+        Returns:
+            StatusResponse: An object containing the success status and an error message if an error occurs.
         """
         response = StatusResponse(False)
-        need_to_close = self.is_connected is False
 
         try:
-            self.connect()
+            connection = self.connect()
+            connection.get_spaces(limit=1)
             response.success = True
         except Exception as e:
             logger.error(f"Error connecting to Confluence API: {e}!")
@@ -86,17 +95,3 @@ class ConfluenceHandler(APIHandler):
         self.is_connected = response.success
 
         return response
-
-    def native_query(self, query: str) -> StatusResponse:
-        """Receive and process a raw query.
-        Parameters
-        ----------
-        query : str
-            query in a native format
-        Returns
-        -------
-        StatusResponse
-            Request status
-        """
-        ast = parse_sql(query)
-        return self.query(ast)