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

mindsdb/integrations/handlers/github_handler/generate_api.py

@@ -0,0 +1,228 @@
+import inspect
+from typing import List
+from dataclasses import dataclass
+
+import pandas as pd
+import github
+
+from mindsdb.integrations.utilities.sql_utils import (FilterCondition, FilterOperator, SortColumn)
+from mindsdb.integrations.libs.api_handler import APIResource
+
+
+@dataclass
+class Type:
+    name: str
+    sub_type: str = None
+    optional: bool = False
+
+
+@dataclass
+class GHMethod:
+    name: str
+    table_name: str
+    params: dict
+    output: Type
+
+
+def parse_annotations(annotations):
+    '''
+    Parse string annotation, and extract type, input examples:
+    - Milestone | Opt[str]
+    - PaginatedList[Issue]
+    '''
+    type_name, sub_type = None, None
+    if not isinstance(annotations, str):
+
+        return Type(getattr(annotations, '__name__', None))
+    for item in annotations.split('|'):
+        item = item.strip()
+        if item is None:
+            continue
+        if '[' in item:
+            type_name = item[: item.find('[')]
+            item2 = item[item.find('[') + 1: item.rfind(']')]
+            if type_name == 'Opt':
+                inner_type = parse_annotations(item2)
+                inner_type.optional = Type
+                return inner_type
+            if type_name == 'dict':
+                item2 = item2[item2.find(',') + 1:]
+            sub_type = parse_annotations(item2).name
+        else:
+            type_name = item
+        # get only first type
+        break
+    return Type(type_name, sub_type)
+
+
+def get_properties(cls):
+    # find properties of the class
+
+    properties = {}
+    for prop_name, prop in inspect.getmembers(cls):
+        if prop_name.startswith('_'):
+            continue
+        if not isinstance(prop, property):
+            continue
+        sig2 = inspect.signature(prop.fget)
+
+        properties[prop_name] = parse_annotations(sig2.return_annotation)
+    return properties
+
+
+def get_github_types():
+    # get github types
+    types = {}
+
+    GithubObject = github.GithubObject.GithubObject
+    for module_name, module in inspect.getmembers(github, inspect.ismodule):
+        cls = getattr(module, module_name, None)
+        if cls is None:
+            continue
+        if issubclass(cls, GithubObject):
+
+            # remove inherited props
+            parent_props = []
+            for cls2 in cls.__bases__:
+                parent_props += get_properties(cls2).keys()
+
+            properties = {}
+            for k, v in get_properties(cls).items():
+                if k not in parent_props:
+                    properties[k] = v
+
+            types[module_name] = properties
+    return types
+
+
+def get_github_methods(cls):
+    '''
+    Analyse class in order to find methods which return list of objects.
+    '''
+    methods = []
+
+    for method_name, method in inspect.getmembers(cls, inspect.isfunction):
+        sig = inspect.signature(method)
+
+        return_type = parse_annotations(sig.return_annotation)
+        list_prefix = 'get_'
+        if not (method_name.startswith(list_prefix) and return_type.name == 'PaginatedList'):
+            continue
+
+        table_name = method_name[len(list_prefix):]
+
+        params = {}
+        for param_name, param in sig.parameters.items():
+            params[param_name] = parse_annotations(param.annotation)
+
+        methods.append(GHMethod(
+            name=method_name,
+            table_name=table_name,
+            params=params,
+            output=return_type
+        ))
+    return methods
+
+
+class GHTable(APIResource):
+    def __init__(self, *args, method: GHMethod = None, github_types=None, **kwargs):
+        self.method = method
+        self.github_types = github_types
+
+        self.output_columns = {}
+        if method.output.sub_type in self.github_types:
+            self.output_columns = self.github_types[method.output.sub_type]
+
+        # check params:
+        self.params, self.list_params = [], []
+        for name, param_type in method.params.items():
+            self.params.append(name)
+            if param_type.name == 'list':
+                self.list_params.append(name)
+
+        self._allow_sort = 'sort' in method.params
+
+        super().__init__(*args, **kwargs)
+
+    def repr_value(self, value, type_name):
+        if value is None or type_name in ('bool', 'int', 'float'):
+            return value
+        if type_name in self.github_types:
+            properties = self.github_types[type_name]
+            if 'login' in properties:
+                value = getattr(value, 'login')
+            elif 'url' in properties:
+                value = getattr(value, 'url')
+        return str(value)
+
+    def get_columns(self) -> List[str]:
+        return list(self.output_columns.keys())
+
+    def list(
+        self,
+        conditions: List[FilterCondition] = None,
+        limit: int = None,
+        sort: List[SortColumn] = None,
+        targets: List[str] = None,
+        **kwargs
+    ) -> pd.DataFrame:
+
+        if limit is None:
+            limit = 20
+
+        method_kwargs = {}
+        if sort is not None and self._allow_sort:
+            for col in sort:
+                method_kwargs['sort'] = col.column
+                method_kwargs['direction'] = 'asc' if col.ascending else 'desc'
+                sort.applied = True
+                # supported only 1 column
+                break
+
+        if conditions:
+            for condition in conditions:
+                if condition.column not in self.params:
+                    continue
+
+                if condition.column in self.list_params:
+                    if condition.op == FilterOperator.IN:
+                        method_kwargs[condition.column] = condition.value
+                    elif condition.op == FilterOperator.EQUAL:
+                        method_kwargs[condition.column] = [condition]
+                    condition.applied = True
+                else:
+                    method_kwargs[condition.column] = condition.value
+                    condition.applied = True
+
+        connection = self.handler.connect()
+        method = getattr(connection.get_repo(self.handler.repository), self.method.name)
+
+        data = []
+        count = 0
+        for record in method(**method_kwargs):
+            item = {}
+            for name, output_type in self.output_columns.items():
+
+                # workaround to prevent making addition request per property.
+                if name in targets:
+                    # request only if is required
+                    value = getattr(record, name)
+                else:
+                    value = getattr(record, '_' + name).value
+                if value is not None:
+                    if output_type.name == 'list':
+                        value = ",".join([
+                                str(self.repr_value(i, output_type.sub_type))
+                                for i in value
+                        ])
+                    else:
+                        value = self.repr_value(value, output_type.name)
+                item[name] = value
+
+            data.append(item)
+
+            count += 1
+            if limit <= count:
+                break
+
+        return pd.DataFrame(data, columns=self.get_columns())

mindsdb/integrations/handlers/github_handler/github_handler.py

@@ -12,7 +12,7 @@ from mindsdb.integrations.handlers.github_handler.github_tables import (
     GithubMilestonesTable,
     GithubProjectsTable, GithubFilesTable
 )
-
+from mindsdb.integrations.handlers.github_handler.generate_api import get_github_types, get_github_methods, GHTable
 from mindsdb.integrations.libs.api_handler import APIHandler
 from mindsdb.integrations.libs.response import (
     HandlerStatusResponse as StatusResponse,
@@ -22,6 +22,7 @@ from mindsdb.utilities import log
 
 logger = log.getLogger(__name__)
 
+
 class GithubHandler(APIHandler):
     """The GitHub handler implementation"""
 
@@ -43,16 +44,22 @@ class GithubHandler(APIHandler):
         self.connection = None
         self.is_connected = False
 
+        # custom tables
         self._register_table("issues", GithubIssuesTable(self))
-        self._register_table("pull_requests", GithubPullRequestsTable(self))
-        self._register_table("commits", GithubCommitsTable(self))
-        self._register_table("releases", GithubReleasesTable(self))
-        self._register_table("branches", GithubBranchesTable(self))
-        self._register_table("contributors", GithubContributorsTable(self))
-        self._register_table("milestones", GithubMilestonesTable(self))
-        self._register_table("projects", GithubProjectsTable(self))
         self._register_table("files", GithubFilesTable(self))
 
+        # generated tables
+        github_types = get_github_types()
+
+        # generate tables from repository object
+        for method in get_github_methods(github.Repository.Repository):
+            if method.table_name in self._tables:
+                continue
+
+            table = GHTable(self, github_types=github_types, method=method)
+            self._register_table(method.table_name, table)
+
+
     def connect(self) -> StatusResponse:
         """Set up the connection required by the handler.
 

mindsdb/integrations/handlers/github_handler/requirements.txt

@@ -1 +1 @@
-pygithub
+pygithub==2.6.1

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