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

mindsdb/integrations/handlers/confluence_handler/connection_args.py

@@ -4,29 +4,29 @@ from mindsdb.integrations.libs.const import HANDLER_CONNECTION_ARG_TYPE as ARG_T
 
 
 connection_args = OrderedDict(
-    url={
+    api_base={
         "type": ARG_TYPE.URL,
-        "description": "Confluence URL",
-        "label": "url",
+        "description": "The base URL of the Confluence instance/server.",
+        "label": "Base URL",
         "required": True
     },
     username={
         "type": ARG_TYPE.STR,
-        "description": "Confluence username",
-        "label": "username",
+        "description": "The username for the Confluence account.",
+        "label": "Username",
         "required": True
     },
     password={
         "type": ARG_TYPE.STR,
-        "description": "Password",
-        "label": "password",
+        "description": "The API token for the Confluence account.",
+        "label": "Password",
         "required": True,
         "secret": True
     }
 )
 
 connection_args_example = OrderedDict(
-    url="https://marios.atlassian.net/",
+    api_base="https://marios.atlassian.net/",
     username="your_username",
     password="access_token"
 )

mindsdb/integrations/handlers/dummy_data_handler/dummy_data_handler.py

@@ -1,4 +1,5 @@
 import time
+from typing import Optional, List
 
 import duckdb
 from typing import Any
@@ -36,18 +37,27 @@ class DummyHandler(DatabaseHandler):
         """
         return HandlerStatusResponse(success=True)
 
-    def native_query(self, query: Any) -> HandlerResponse:
+    def native_query(self, query: Any, params: Optional[List] = None) -> HandlerResponse:
         """Receive raw query and act upon it somehow
 
         Args:
-            query (Any): query in native format (str for sql databases,
-                dict for mongo, etc)
+            query (Any): query in native format (str for sql databases, dict for mongo, etc)
+            params (Optional[List])
 
         Returns:
             HandlerResponse
         """
         con = duckdb.connect(self.db_path)
-        result_df = con.execute(query).fetchdf()
+        if params is not None:
+            query = query.replace('%s', '?')
+            cur = con.executemany(query, params)
+            if cur.rowcount >= 0:
+                result_df = cur.fetchdf()
+            else:
+                con.close()
+                return HandlerResponse(RESPONSE_TYPE.OK)
+        else:
+            result_df = con.execute(query).fetchdf()
         con.close()
         return HandlerResponse(RESPONSE_TYPE.TABLE, result_df)
 
@@ -62,8 +72,8 @@ class DummyHandler(DatabaseHandler):
             HandlerResponse
         """
         renderer = SqlalchemyRender('postgres')
-        query_str = renderer.get_string(query, with_failback=True)
-        return self.native_query(query_str)
+        query_str, params = renderer.get_exec_params(query, with_failback=True)
+        return self.native_query(query_str, params)
 
     def get_tables(self) -> HandlerResponse:
         """Get a list of all the tables in the database

mindsdb/integrations/handlers/file_handler/tests/test_file_handler.py

@@ -8,7 +8,6 @@ import pandas
 import pytest
 from mindsdb_sql_parser.exceptions import ParsingException
 from mindsdb_sql_parser.ast import CreateTable, DropTables, Identifier, Insert, TableColumn, Update
-from pytest_lazyfixture import lazy_fixture
 
 from mindsdb.integrations.handlers.file_handler.file_handler import FileHandler
 from mindsdb.integrations.libs.response import RESPONSE_TYPE
@@ -75,33 +74,26 @@ def curr_dir():
     return os.path.dirname(os.path.realpath(__file__))
 
 
-# Fixtures to get a path to a partiular type of file
-@pytest.fixture
 def csv_file() -> str:
     return os.path.join(curr_dir(), "data", "test.csv")
 
 
-@pytest.fixture
 def xlsx_file() -> str:
     return os.path.join(curr_dir(), "data", "test.xlsx")
 
 
-@pytest.fixture
 def json_file() -> str:
     return os.path.join(curr_dir(), "data", "test.json")
 
 
-@pytest.fixture
 def parquet_file() -> str:
     return os.path.join(curr_dir(), "data", "test.parquet")
 
 
-@pytest.fixture
 def pdf_file() -> str:
     return os.path.join(curr_dir(), "data", "test.pdf")
 
 
-@pytest.fixture
 def txt_file() -> str:
     return os.path.join(curr_dir(), "data", "test.txt")
 
@@ -109,56 +101,47 @@ def txt_file() -> str:
 class TestIsItX:
     """Tests all of the 'is_it_x()' functions to determine a file's type"""
 
-    # We can't test xlsx or parquet here because they're binary files
-    @pytest.mark.parametrize(
-        "file_path,result",
-        [(lazy_fixture("csv_file"), True), (lazy_fixture("json_file"), False)],
-    )
-    def test_is_it_csv(self, file_path, result):
-        with open(file_path, "r") as fh:
-            assert FileReader.is_csv(StringIO(fh.read())) is result
-
-    @pytest.mark.parametrize(
-        "file_path,result",
-        [
-            (lazy_fixture("csv_file"), 'csv'),
-            (lazy_fixture("xlsx_file"), 'xlsx'),
-            (lazy_fixture("json_file"), 'json'),
-            (lazy_fixture("parquet_file"), 'parquet'),
-            (lazy_fixture("txt_file"), 'txt'),
-            (lazy_fixture("pdf_file"), 'pdf'),
-        ],
-    )
-    def test_format(self, file_path, result):
-        assert FileReader(path=file_path).get_format() == result
-
-    # We can't test xlsx or parquet here because they're binary files
-    @pytest.mark.parametrize(
-        "file_path,result",
-        [
-            (lazy_fixture("csv_file"), False),
-            (lazy_fixture("json_file"), True),
-            (lazy_fixture("txt_file"), False),
-        ],
-    )
-    def test_is_it_json(self, file_path, result):
-        with open(file_path, "r") as fh:
-            assert FileReader.is_json(StringIO(fh.read())) is result
-
-    @pytest.mark.parametrize(
-        "file_path,result",
-        [
-            (lazy_fixture("csv_file"), False),
-            (lazy_fixture("xlsx_file"), False),
-            (lazy_fixture("json_file"), False),
-            (lazy_fixture("parquet_file"), True),
-            (lazy_fixture("txt_file"), False),
-            (lazy_fixture("pdf_file"), False),
-        ],
-    )
-    def test_is_it_parquet(self, file_path, result):
-        with open(file_path, "rb") as fh:
-            assert FileReader.is_parquet(BytesIO(fh.read())) is result
+    def test_is_it_csv(self):
+        # We can't test xlsx or parquet here because they're binary files
+        for file_path, result in (
+            (csv_file(), True),
+            (json_file(), False)
+        ):
+            with open(file_path, "r") as fh:
+                assert FileReader.is_csv(StringIO(fh.read())) is result
+
+    def test_format(self):
+        for file_path, result in (
+            (csv_file(), 'csv'),
+            (xlsx_file(), 'xlsx'),
+            (json_file(), 'json'),
+            (parquet_file(), 'parquet'),
+            (txt_file(), 'txt'),
+            (pdf_file(), 'pdf'),
+        ):
+            assert FileReader(path=file_path).get_format() == result
+
+    def test_is_it_json(self):
+        # We can't test xlsx or parquet here because they're binary files
+        for file_path, result in (
+            (csv_file(), False),
+            (json_file(), True),
+            (txt_file(), False),
+        ):
+            with open(file_path, "r") as fh:
+                assert FileReader.is_json(StringIO(fh.read())) is result
+
+    def test_is_it_parquet(self):
+        for file_path, result in (
+            (csv_file(), False),
+            (xlsx_file(), False),
+            (json_file(), False),
+            (parquet_file(), True),
+            (txt_file(), False),
+            (pdf_file(), False),
+        ):
+            with open(file_path, "rb") as fh:
+                assert FileReader.is_parquet(BytesIO(fh.read())) is result
 
 
 class TestQuery:
@@ -188,13 +171,14 @@ class TestQuery:
 
         assert response.type == RESPONSE_TYPE.ERROR
 
-    def test_query_insert(self, csv_file, monkeypatch):
+    def test_query_insert(self, monkeypatch):
         """Test an invalid insert query"""
         # Create a temporary file to save the csv file to.
+        csv_file_path = csv_file()
         csv_tmp = os.path.join(tempfile.gettempdir(), "test.csv")
         if os.path.exists(csv_tmp):
             os.remove(csv_tmp)
-        shutil.copy(csv_file, csv_tmp)
+        shutil.copy(csv_file_path, csv_tmp)
 
         def mock_get_file_path(self, name):
             return csv_tmp
@@ -270,18 +254,7 @@ class TestQuery:
             file_handler.native_query("INVALID QUERY")
 
 
-@pytest.mark.parametrize(
-    "file_path,expected_columns",
-    [
-        (lazy_fixture("csv_file"), test_file_content[0]),
-        (lazy_fixture("xlsx_file"), test_file_content[0]),
-        (lazy_fixture("json_file"), test_file_content[0]),
-        (lazy_fixture("parquet_file"), test_file_content[0]),
-        (lazy_fixture("pdf_file"), ["content", "metadata"]),
-        (lazy_fixture("txt_file"), ["content", "metadata"]),
-    ],
-)
-def test_handle_source(file_path, expected_columns):
+def test_handle_source():
 
     def get_reader(file_path):
         # using path
@@ -300,17 +273,25 @@ def test_handle_source(file_path, expected_columns):
         reader = FileReader(file=fd, name=Path(file_path).name)
         yield reader
 
-    # using different methods to create reader
-    for reader in get_reader(file_path):
-        df = reader.get_page_content()
-        assert isinstance(df, pandas.DataFrame)
-
-        assert df.columns.tolist() == expected_columns
-
-        # The pdf and txt files have some different content
-        if reader.get_format() not in ("pdf", "txt"):
-            assert len(df) == len(test_file_content) - 1
-            assert df.values.tolist() == test_file_content[1:]
+    for file_path, expected_columns in (
+        (csv_file(), test_file_content[0]),
+        (xlsx_file(), test_file_content[0]),
+        (json_file(), test_file_content[0]),
+        (parquet_file(), test_file_content[0]),
+        (pdf_file(), ["content", "metadata"]),
+        (txt_file(), ["content", "metadata"]),
+    ):
+        # using different methods to create reader
+        for reader in get_reader(file_path):
+            df = reader.get_page_content()
+            assert isinstance(df, pandas.DataFrame)
+
+            assert df.columns.tolist() == expected_columns
+
+            # The pdf and txt files have some different content
+            if reader.get_format() not in ("pdf", "txt"):
+                assert len(df) == len(test_file_content) - 1
+                assert df.values.tolist() == test_file_content[1:]
 
 
 @pytest.mark.parametrize(

mindsdb/integrations/handlers/huggingface_handler/requirements.txt

@@ -1,5 +1,6 @@
+# NOTE: Any changes made here need to be made to requirements_cpu.txt as well
 datasets==2.16.1
-evaluate
-torch
-nltk>=3.9
-huggingface-hub
+evaluate==0.4.3
+nltk==3.9.1
+huggingface-hub==0.29.3
+torch==2.6.0

mindsdb/integrations/handlers/huggingface_handler/requirements_cpu.txt

@@ -1,6 +1,6 @@
-datasets==2.16.1
-evaluate
-nltk>=3.9
-huggingface-hub
 # Needs to be installed with `pip install --extra-index-url https://download.pytorch.org/whl/ .[huggingface_cpu]`
-torch==2.2.0+cpu
+datasets==2.16.1
+evaluate==0.4.3
+nltk==3.9.1
+huggingface-hub==0.29.3
+torch==2.6.0+cpu

mindsdb/integrations/handlers/langchain_handler/requirements.txt

@@ -1,7 +1,7 @@
 wikipedia==1.4.0
 tiktoken
 anthropic>=0.26.1
-litellm==1.44.8
+litellm==1.63.14
 chromadb~=0.6.3 # Knowledge bases.
 -r mindsdb/integrations/handlers/openai_handler/requirements.txt
 -r mindsdb/integrations/handlers/langchain_embedding_handler/requirements.txt

mindsdb/integrations/handlers/lightwood_handler/requirements.txt

@@ -1,4 +1,4 @@
-lightwood>=25.2.2.0
-lightwood[extra]>=25.2.2.0
-lightwood[xai]>=25.2.2.0
+lightwood>=25.3.3.3
+lightwood[extra]>=25.3.3.3
+lightwood[xai]>=25.3.3.3
 type_infer==0.0.20

mindsdb/integrations/handlers/litellm_handler/requirements.txt

@@ -1,2 +1,2 @@
-litellm==1.44.8
+litellm==1.63.14
 

mindsdb/integrations/handlers/llama_index_handler/requirements.txt

@@ -1,4 +1,4 @@
-llama-index==0.10.13
+llama-index==0.12.21
 pydantic-settings >= 2.1.0
 llama-index-readers-web
 llama-index-embeddings-openai

mindsdb/integrations/handlers/ms_one_drive_handler/ms_graph_api_one_drive_client.py

@@ -99,4 +99,4 @@ class MSGraphAPIOneDriveClient(MSGraphAPIBaseClient):
         Returns:
             bytes: The content of the specified item.
         """
-        return self.fetch_data(f"me/drive/root:/{path}:/content")
+        return self.fetch_data_content(f"me/drive/root:/{path}:/content")

mindsdb/integrations/handlers/ms_teams_handler/ms_graph_api_teams_client.py

@@ -0,0 +1,278 @@
+from typing import Text, List, Dict, Optional
+
+from requests.exceptions import RequestException
+
+from mindsdb.integrations.utilities.handlers.api_utilities.microsoft.ms_graph_api_utilities import MSGraphAPIBaseClient
+from mindsdb.utilities import log
+
+logger = log.getLogger(__name__)
+
+
+class MSGraphAPITeamsDelegatedPermissionsClient(MSGraphAPIBaseClient): 
+    """
+    The Microsoft Graph API client for the Microsoft Teams handler with delegated permissions.
+    This client is used for accessing the Microsoft Teams specific endpoints of the Microsoft Graph API.
+    Several common methods for submitting requests, fetching data, etc. are inherited from the base class.
+    """
+
+    def check_connection(self) -> bool:
+        """
+        Check if the connection to Microsoft Teams is established.
+
+        Returns:
+            bool: True if the connection is established, False otherwise.
+        """
+        try:
+            self.fetch_data_json("me/joinedTeams")
+            return True
+        except RequestException as request_error:
+            logger.error(f"Failed to check connection to Microsoft Teams: {request_error}")
+            return False
+        
+    def get_all_groups(self) -> List[Dict]:
+        """
+        Get all groups that the signed in user is a member of.
+
+        Returns:
+            List[Dict]: The groups data.
+        """
+        return self.fetch_data_json("me/joinedTeams")
+        
+    def _get_all_group_ids(self) -> List[Text]:
+        """
+        Get all group IDs related to Microsoft Teams.
+
+        Returns:
+            List[Text]: The group IDs.
+        """
+        if not self._group_ids:
+            groups = self.get_all_groups()
+            self._group_ids = [group["id"] for group in groups]
+
+        return self._group_ids
+    
+    def get_channel_in_group_by_id(self, group_id: Text, channel_id: Text) -> Dict:
+        """
+        Get a channel by its ID and the ID of the group that it belongs to.
+
+        Args:
+            group_id (Text): The ID of the group that the channel belongs to.
+            channel_id (Text): The ID of the channel.
+
+        Returns:
+            Dict: The channel data.
+        """
+        channel = self.fetch_data_json(f"teams/{group_id}/channels/{channel_id}")
+        # Add the group ID to the channel data.
+        channel.update({"teamId": group_id})
+
+        return channel
+    
+    def get_channels_in_group_by_ids(self, group_id: Text, channel_ids: List[Text]) -> List[Dict]:
+        """
+        Get channels by their IDs and the ID of the group that they belong to.
+
+        Args:
+            group_id (Text): The ID of the group that the channels belong to.
+            channel_ids (List[Text]): The IDs of the channels.
+
+        Returns:
+            List[Dict]: The channels data.
+        """
+        channels = []
+        for channel_id in channel_ids:
+            channels.append(self.get_channel_in_group_by_id(group_id, channel_id))
+
+        return channels
+    
+    def get_all_channels_in_group(self, group_id: Text) -> List[Dict]:
+        """
+        Get all channels of a group by its ID.
+
+        Args:
+            group_id (Text): The ID of the group.
+
+        Returns:
+            List[Dict]: The channels data.
+        """
+        channels = self.fetch_data_json(f"teams/{group_id}/channels")
+        for channel in channels:
+            channel["teamId"] = group_id
+
+        return channels
+    
+    def get_all_channels_across_all_groups(self) -> List[Dict]:
+        """
+        Get all channels across all groups that the signed in user is a member of.
+
+        Returns:
+            List[Dict]: The channels data.
+        """
+        channels = []
+        for group_id in self._get_all_group_ids():
+            channels += self.get_all_channels_in_group(group_id)
+
+        return channels
+    
+    def get_channels_across_all_groups_by_ids(self, channel_ids: List[Text]) -> List[Dict]:
+        """
+        Get channels by their IDs.
+
+        Args:
+            channel_ids (List[Text]): The IDs of the channels.
+
+        Returns:
+            List[Dict]: The channels data.
+        """
+        channels = self.get_all_channels_across_all_groups()
+
+        return [channel for channel in channels if channel["id"] in channel_ids]
+    
+    def get_message_in_channel_by_id(self, group_id: Text, channel_id: Text, message_id: Text) -> Dict:
+        """
+        Get a message by its ID, the ID of the group that it belongs to, and the ID of the channel that it belongs to.
+
+        Args:
+            group_id (Text): The ID of the group that the channel belongs to.
+            channel_id (Text): The ID of the channel that the message belongs to.
+            message_id (Text): The ID of the message.
+
+        Returns:
+            Dict: The message data.
+        """
+        return self.fetch_data_json(f"teams/{group_id}/channels/{channel_id}/messages/{message_id}")
+    
+    def get_messages_in_channel_by_ids(self, group_id: Text, channel_id: Text, message_ids: List[Text]) -> List[Dict]:
+        """
+        Get messages by their IDs, the ID of the group that they belong to, and the ID of the channel that they belong to.
+
+        Args:
+            group_id (Text): The ID of the group that the channel belongs to.
+            channel_id (Text): The ID of the channel that the messages belong to.
+            message_ids (List[Text]): The IDs of the messages.
+
+        Returns:
+            List[Dict]: The messages data.
+        """
+        messages = []
+        for message_id in message_ids:
+            messages.append(self.get_message_in_channel_by_id(group_id, channel_id, message_id))
+
+        return messages
+
+    def get_all_messages_in_channel(self, group_id: Text, channel_id: Text, limit: int = None) -> List[Dict]:
+        """
+        Get messages of a channel by its ID and the ID of the group that it belongs to.
+
+        Args:
+            group_id (Text): The ID of the group that the channel belongs to.
+            channel_id (Text): The ID of the channel.
+
+        Returns:
+            List[Dict]: The messages data.
+        """
+        messages = []
+        for messages_batch in self.fetch_paginated_data(f"teams/{group_id}/channels/{channel_id}/messages"):
+            messages += messages_batch
+
+            if limit and len(messages) >= limit:
+                break
+
+        return messages[:limit]
+    
+    def get_chat_by_id(self, chat_id: Text) -> Dict:
+        """
+        Get a chat by its ID.
+
+        Args:
+            chat_id (Text): The ID of the chat.
+
+        Returns:
+            Dict: The chat data.
+        """
+        return self.fetch_data_json(f"/me/chats/{chat_id}")
+    
+    def get_chats_by_ids(self, chat_ids: List[Text]) -> List[Dict]:
+        """
+        Get chats by their IDs.
+
+        Args:
+            chat_ids (List[Text]): The IDs of the chats.
+
+        Returns:
+            List[Dict]: The chats data.
+        """
+        chats = []
+        for chat_id in chat_ids:
+            chats.append(self.get_chat_by_id(chat_id))
+
+        return chats
+
+    def get_all_chats(self, limit: int = None) -> List[Dict]:
+        """
+        Get all chats of the signed in user.
+
+        Args:
+            limit (int): The maximum number of chats to return.
+
+        Returns:
+            List[Dict]: The chats data.
+        """
+        chats = []
+        for chat_batch in self.fetch_paginated_data("me/chats"):
+            chats += chat_batch
+
+            if limit and len(chats) >= limit:
+                break
+
+        return chats[:limit]
+    
+    def get_message_in_chat_by_id(self, chat_id: Text, message_id: Text) -> Dict:
+        """
+        Get a message by its ID and the ID of the chat that it belongs to.
+
+        Args:
+            chat_id (Text): The ID of the chat that the message belongs to.
+            message_id (Text): The ID of the message.
+
+        Returns:
+            Dict: The message data.
+        """
+        return self.fetch_data_json(f"me/chats/{chat_id}/messages/{message_id}")
+    
+    def get_messages_in_chat_by_ids(self, chat_id: Text, message_ids: List[Text]) -> List[Dict]:
+        """
+        Get messages by their IDs and the ID of the chat that they belong to.
+
+        Args:
+            chat_id (Text): The ID of the chat that the messages belong to.
+            message_ids (List[Text]): The IDs of the messages.
+
+        Returns:
+            List[Dict]: The messages data.
+        """
+        messages = []
+        for message_id in message_ids:
+            messages.append(self.get_message_in_chat_by_id(chat_id, message_id))
+
+        return messages
+    
+    def get_all_messages_in_chat(self, chat_id: Text, limit: int = None) -> List[Dict]:
+        """
+        Get messages of a chat by its ID.
+
+        Args:
+            chat_id (Text): The ID of the chat.
+
+        Returns:
+            List[Dict]: The messages data.
+        """
+        messages = []
+        for messages_batch in self.fetch_paginated_data(f"me/chats/{chat_id}/messages"):
+            messages += messages_batch
+
+            if limit and len(messages) >= limit:
+                break
+
+        return messages[:limit]
+