MindsDB 25.3.3.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.3.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/api/executor/datahub/datanodes/information_schema_datanode.py

@@ -3,12 +3,8 @@ import pandas as pd
 from mindsdb_sql_parser.ast.base import ASTNode
 
 from mindsdb.api.executor.datahub.datanodes.datanode import DataNode
-from mindsdb.api.executor.datahub.datanodes.integration_datanode import (
-    IntegrationDataNode,
-)
-from mindsdb.api.executor.datahub.datanodes.project_datanode import (
-    ProjectDataNode,
-)
+from mindsdb.api.executor.datahub.datanodes.integration_datanode import IntegrationDataNode
+from mindsdb.api.executor.datahub.datanodes.project_datanode import ProjectDataNode
 from mindsdb.api.executor import exceptions as exc
 from mindsdb.api.executor.utilities.sql import query_df
 from mindsdb.api.executor.utilities.sql import get_query_tables

mindsdb/api/executor/datahub/datanodes/mindsdb_tables.py

@@ -310,7 +310,7 @@ class ChatbotsTable(MdbTable):
         ):
             project_name = query.where.args[1].value
 
-        chatbot_data = chatbot_controller.get_chatbots(project_name)
+        chatbot_data = chatbot_controller.get_chatbots(project_name=project_name)
 
         columns = cls.columns
         columns_lower = [col.lower() for col in columns]

mindsdb/api/http/namespaces/agents.py

@@ -47,7 +47,7 @@ def create_agent(project_name, name, agent):
 
     try:
         existing_agent = agents_controller.get_agent(name, project_name=project_name)
-    except ValueError:
+    except (ValueError, EntityNotExistsError):
         # Project must exist.
         return http_error(
             HTTPStatus.NOT_FOUND,
@@ -141,7 +141,7 @@ class AgentResource(Resource):
                     f'Agent with name {agent_name} does not exist'
                 )
             return existing_agent.as_dict()
-        except ValueError:
+        except (ValueError, EntityNotExistsError):
             # Project needs to exist.
             return http_error(
                 HTTPStatus.NOT_FOUND,
@@ -173,7 +173,11 @@ class AgentResource(Resource):
                 f'Project with name {project_name} does not exist'
             )
         if existing_agent_record is None:
-            raise Exception
+            return http_error(
+                HTTPStatus.BAD_REQUEST,
+                'Creation is not allowed',
+                'Creation of an agent using the PUT method is not allowed.'
+            )
 
         agent = request.json['agent']
         name = agent.get('name', None)
@@ -272,7 +276,7 @@ class AgentResource(Resource):
                     'Agent not found',
                     f'Agent with name {agent_name} does not exist'
                 )
-        except ValueError:
+        except (ValueError, EntityNotExistsError):
             # Project needs to exist.
             return http_error(
                 HTTPStatus.NOT_FOUND,
@@ -435,7 +439,7 @@ class AgentCompletions(Resource):
                     'Agent not found',
                     f'Agent with name {agent_name} does not exist'
                 )
-        except ValueError:
+        except (ValueError, EntityNotExistsError):
             # Project needs to exist.
             return http_error(
                 HTTPStatus.NOT_FOUND,

mindsdb/api/http/namespaces/chatbots.py

@@ -11,6 +11,7 @@ from mindsdb.metrics.metrics import api_endpoint_metrics
 from mindsdb.interfaces.chatbot.chatbot_controller import ChatBotController
 from mindsdb.interfaces.model.functions import PredictorRecordNotFound
 from mindsdb.interfaces.storage.db import Predictor
+from mindsdb.utilities.exception import EntityNotExistsError
 
 
 def create_chatbot(project_name, name, chatbot):
@@ -59,7 +60,7 @@ def create_chatbot(project_name, name, chatbot):
 
     try:
         existing_chatbot = chatbot_controller.get_chatbot(name, project_name=project_name)
-    except ValueError:
+    except EntityNotExistsError:
         # Project must exist.
         return http_error(
             HTTPStatus.NOT_FOUND,
@@ -152,7 +153,7 @@ class ChatBotsResource(Resource):
         chatbot_controller = ChatBotController()
         try:
             all_bots = chatbot_controller.get_chatbots(project_name)
-        except ValueError:
+        except (ValueError, EntityNotExistsError):
             # Project needs to exist.
             return http_error(
                 HTTPStatus.NOT_FOUND,
@@ -197,7 +198,7 @@ class ChatBotResource(Resource):
                     f'Chatbot with name {chatbot_name} does not exist'
                 )
             return existing_chatbot
-        except ValueError:
+        except (ValueError, EntityNotExistsError):
             # Project needs to exist.
             return http_error(
                 HTTPStatus.NOT_FOUND,
@@ -221,7 +222,7 @@ class ChatBotResource(Resource):
 
         try:
             existing_chatbot = chatbot_controller.get_chatbot(chatbot_name, project_name=project_name)
-        except ValueError:
+        except EntityNotExistsError:
             # Project needs to exist.
             return http_error(
                 HTTPStatus.NOT_FOUND,
@@ -306,7 +307,7 @@ class ChatBotResource(Resource):
                     'Chatbot not found',
                     f'Chatbot with name {chatbot_name} does not exist'
                 )
-        except ValueError:
+        except EntityNotExistsError:
             # Project needs to exist.
             return http_error(
                 HTTPStatus.NOT_FOUND,

mindsdb/api/http/namespaces/databases.py

@@ -1,10 +1,9 @@
-from http import HTTPStatus
-import tempfile
 import time
+import shutil
+import tempfile
+from http import HTTPStatus
 from typing import Dict
 from pathlib import Path
-import shutil
-from sqlalchemy.exc import NoResultFound
 
 from flask import request
 from flask_restx import Resource
@@ -337,7 +336,7 @@ class TablesList(Resource):
                 HTTPStatus.BAD_REQUEST, 'Error',
                 error_message
             )
-        except NoResultFound:
+        except EntityNotExistsError:
             # Only support creating tables from integrations.
             pass
 
@@ -419,7 +418,7 @@ class TableResource(Resource):
                 + f'If you want to delete a model or view, use the projects/{database_name}/models/{table_name} or ' \
                 + f'projects/{database_name}/views/{table_name} endpoints instead.'
             return http_error(HTTPStatus.BAD_REQUEST, 'Error', error_message)
-        except NoResultFound:
+        except EntityNotExistsError:
             # Only support dropping tables from integrations.
             pass
 

mindsdb/api/http/namespaces/skills.py

@@ -7,6 +7,7 @@ from mindsdb.metrics.metrics import api_endpoint_metrics
 from mindsdb.api.http.namespaces.configs.projects import ns_conf
 from mindsdb.api.http.utils import http_error
 from mindsdb.interfaces.skills.skills_controller import SkillsController
+from mindsdb.utilities.exception import EntityNotExistsError
 
 
 def create_skill(project_name, skill):
@@ -52,7 +53,7 @@ class SkillsResource(Resource):
         skills_controller = SkillsController()
         try:
             all_skills = skills_controller.get_skills(project_name)
-        except ValueError:
+        except EntityNotExistsError:
             # Project needs to exist.
             return http_error(
                 HTTPStatus.NOT_FOUND,
@@ -88,7 +89,7 @@ class SkillResource(Resource):
         skills_controller = SkillsController()
         try:
             existing_skill = skills_controller.get_skill(skill_name, project_name)
-        except ValueError:
+        except EntityNotExistsError:
             # Project needs to exist
             return http_error(
                 HTTPStatus.NOT_FOUND,
@@ -120,7 +121,7 @@ class SkillResource(Resource):
 
         try:
             existing_skill = skills_controller.get_skill(skill_name, project_name)
-        except ValueError:
+        except EntityNotExistsError:
             # Project needs to exist
             return http_error(
                 HTTPStatus.NOT_FOUND,
@@ -152,7 +153,7 @@ class SkillResource(Resource):
         skills_controller = SkillsController()
         try:
             existing_skill = skills_controller.get_skill(skill_name, project_name)
-        except ValueError:
+        except EntityNotExistsError:
             # Project needs to exist
             return http_error(
                 HTTPStatus.NOT_FOUND,

mindsdb/api/http/namespaces/views.py

@@ -2,13 +2,12 @@ from http import HTTPStatus
 
 from flask import request
 from flask_restx import Resource
-from sqlalchemy.exc import NoResultFound
-
 
 from mindsdb.api.http.utils import http_error
 from mindsdb.api.http.namespaces.configs.projects import ns_conf
 from mindsdb.api.executor.controllers.session_controller import SessionController
 from mindsdb.metrics.metrics import api_endpoint_metrics
+from mindsdb.utilities.exception import EntityNotExistsError
 
 
 @ns_conf.route('/<project_name>/views')
@@ -20,7 +19,7 @@ class ViewsList(Resource):
         session = SessionController()
         try:
             project = session.database_controller.get_project(project_name)
-        except NoResultFound:
+        except EntityNotExistsError:
             return http_error(
                 HTTPStatus.NOT_FOUND,
                 'Project not found',
@@ -55,7 +54,7 @@ class ViewsList(Resource):
 
         try:
             project = session.database_controller.get_project(project_name)
-        except NoResultFound:
+        except EntityNotExistsError:
             return http_error(HTTPStatus.NOT_FOUND, 'Not found', f'Project name {project_name} does not exist')
 
         if project.get_view(name) is not None:
@@ -82,7 +81,7 @@ class ViewResource(Resource):
         session = SessionController()
         try:
             project = session.database_controller.get_project(project_name)
-        except NoResultFound:
+        except EntityNotExistsError:
             return http_error(HTTPStatus.NOT_FOUND, 'Project not found', f'Project name {project_name} does not exist')
 
         view = project.get_view(view_name)
@@ -106,7 +105,7 @@ class ViewResource(Resource):
         session = SessionController()
         try:
             project = session.database_controller.get_project(project_name)
-        except NoResultFound:
+        except EntityNotExistsError:
             return http_error(HTTPStatus.NOT_FOUND, 'Project not found', f'Project name {project_name} does not exist')
 
         existing_view = project.get_view(view_name)
@@ -143,7 +142,7 @@ class ViewResource(Resource):
         session = SessionController()
         try:
             project = session.database_controller.get_project(project_name)
-        except NoResultFound:
+        except EntityNotExistsError:
             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:

mindsdb/integrations/handlers/chromadb_handler/chromadb_handler.py

@@ -210,6 +210,7 @@ class ChromaDBHandler(VectorStoreHandler):
         chroma_db_conditions = []
         for condition in metadata_conditions:
             metadata_key = condition.column.split(".")[-1]
+
             chroma_db_conditions.append(
                 {
                     metadata_key: {
@@ -310,9 +311,29 @@ class ChromaDBHandler(VectorStoreHandler):
             payload = {column: payload[column] for column in columns}
 
         # always include distance
+        distance_filter = None
+        distance_col = TableField.DISTANCE.value
         if distances is not None:
-            payload[TableField.DISTANCE.value] = distances
-        return pd.DataFrame(payload)
+            payload[distance_col] = distances
+
+            for cond in conditions:
+                if cond.column == distance_col:
+                    distance_filter = cond
+                    break
+
+        df = pd.DataFrame(payload)
+        if distance_filter is not None:
+            op_map = {
+                '<': '__lt__',
+                '<=': '__le__',
+                '>': '__gt__',
+                '>=': '__ge__',
+                '=': '__eq__',
+            }
+            op = op_map.get(distance_filter.op.value)
+            if op:
+                df = df[getattr(df[distance_col], op)(distance_filter.value)]
+        return df
 
     def _dataframe_metadata_to_chroma_metadata(self, metadata: Union[Dict[str, str], str]) -> Optional[Dict[str, str]]:
         """Convert DataFrame metadata to ChromaDB compatible metadata format"""

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)