MindsDB 25.4.5.0__py3-none-any.whl → 25.5.3.0__py3-none-any.whl

mindsdb/integrations/handlers/jira_handler/jira_handler.archived.py

@@ -0,0 +1,75 @@
+from mindsdb.integrations.libs.api_handler import APIHandler
+from mindsdb.integrations.libs.response import (
+    HandlerStatusResponse as StatusResponse,
+)
+from mindsdb.utilities import log
+from mindsdb.integrations.libs.api_handler_generator import APIResourceGenerator
+
+
+logger = log.getLogger(__name__)
+
+
+class JiraHandler(APIHandler):
+
+    def __init__(self, name=None, **kwargs):
+        """
+        Initialize the handler.
+        Args:
+            name (str): name of particular handler instance
+            connection_data (dict): parameters for connecting to the database
+            **kwargs: arbitrary keyword arguments.
+        """
+        super().__init__(name)
+        self.connection_data = kwargs.get("connection_data", {})
+
+        self.connection = None
+        self.is_connected = False
+
+        # todo store parsed data in files
+
+        self.api_resource_generator = APIResourceGenerator(
+            "https://developer.atlassian.com/cloud/jira/platform/swagger-v3.v3.json",
+            self.connection_data,
+            url_base='/rest/api/3/',
+            options={
+                'offset_param': ['startAt', 'offset'],
+                'total_column': ['totalEntryCount', 'total'],
+                'check_connection_table': 'myself'
+            }
+        )
+
+        resource_tables = self.api_resource_generator.generate_api_resources(self)
+
+        for table_name, resource in resource_tables.items():
+            self._register_table(table_name, resource)
+
+    def __del__(self):
+        if self.is_connected is True:
+            self.disconnect()
+
+    def connect(self):
+        """
+        Set up the connection required by the handler.
+        Returns:
+            HandlerStatusResponse
+        """
+        return
+
+    def check_connection(self) -> StatusResponse:
+        """
+        Check connection to the handler.
+        Returns:
+            HandlerStatusResponse
+        """
+
+        response = StatusResponse(False)
+
+        try:
+            self.api_resource_generator.check_connection()
+            response.success = True
+        except Exception as e:
+            logger.error(f"Error connecting to Jira API: {e}!")
+            response.error_message = e
+
+        self.is_connected = response.success
+        return response

mindsdb/integrations/handlers/jira_handler/jira_handler.py

@@ -1,75 +1,150 @@
+from typing import Any, Dict
+
+from atlassian import Jira
+from requests.exceptions import HTTPError
+
+from mindsdb.integrations.handlers.jira_handler.jira_tables import JiraProjectsTable, JiraIssuesTable, JiraUsersTable, JiraGroupsTable
 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
-from mindsdb.integrations.libs.api_handler_generator import APIResourceGenerator
 
 
 logger = log.getLogger(__name__)
 
 
 class JiraHandler(APIHandler):
+    """
+    This handler handles the connection and execution of SQL statements on Jira.
+    """
 
-    def __init__(self, name=None, **kwargs):
+    def __init__(self, name: str, connection_data: Dict, **kwargs: Any) -> None:
         """
-        Initialize the handler.
+        Initializes the handler.
+
         Args:
-            name (str): name of particular handler instance
-            connection_data (dict): parameters for connecting to the database
-            **kwargs: arbitrary keyword arguments.
+            name (Text): The name of the handler instance.
+            connection_data (Dict): The connection data required to connect to the Jira API.
+            kwargs: Arbitrary keyword arguments.
         """
         super().__init__(name)
-        self.connection_data = kwargs.get("connection_data", {})
+        self.connection_data = connection_data
+        self.kwargs = kwargs
 
         self.connection = None
         self.is_connected = False
 
-        # todo store parsed data in files
+        self._register_table("projects", JiraProjectsTable(self))
+        self._register_table("issues", JiraIssuesTable(self))
+        self._register_table("groups", JiraGroupsTable(self))
+        self._register_table("users", JiraUsersTable(self))
 
-        self.api_resource_generator = APIResourceGenerator(
-            "https://developer.atlassian.com/cloud/jira/platform/swagger-v3.v3.json",
-            self.connection_data,
-            url_base='/rest/api/3/',
-            options={
-                'offset_param': ['startAt', 'offset'],
-                'total_column': ['totalEntryCount', 'total'],
-                'check_connection_table': 'myself'
-            }
-        )
-
-        resource_tables = self.api_resource_generator.generate_api_resources(self)
-
-        for table_name, resource in resource_tables.items():
-            self._register_table(table_name, resource)
+    def connect(self) -> Jira:
+        """
+        Establishes a connection to the Jira API.
 
-    def __del__(self):
-        if self.is_connected is True:
-            self.disconnect()
+        Raises:
+            ValueError: If the required connection parameters are not provided.
+            AuthenticationError: If an authentication error occurs while connecting to the Salesforce API.
 
-    def connect(self):
-        """
-        Set up the connection required by the handler.
         Returns:
-            HandlerStatusResponse
+            atlassian.jira.Jira: A connection object to the Jira API.
         """
-        return
+        if self.is_connected is True:
+            return self.connection
+        
+        is_cloud = self.connection_data.get("cloud", True)
+
+        if is_cloud:
+            # Jira Cloud supports API token authentication.
+            if not all(key in self.connection_data for key in ['username', 'api_token', 'url']):
+                raise ValueError("Required parameters (username, api_token, url) must be provided.")
+            
+            config = {
+                "username": self.connection_data['username'],
+                "password": self.connection_data['api_token'],
+                "url": self.connection_data['url'],
+            }
+        else:
+            # Jira Server supports personal access token authentication or open access.
+            if 'url' not in self.connection_data:
+                raise ValueError("Required parameter 'url' must be provided.")
+            
+            config = {
+                "url": self.connection_data['url'],
+                "cloud": False
+            }
+
+            if 'personal_access_token' in self.connection_data:
+                config['session'] = ({"Authorization": f"Bearer {self.connection_data['personal_access_token']}"})
+
+        try:
+            self.connection = Jira(**config)
+            self.is_connected = True
+            return self.connection
+        except Exception as unknown_error:
+            logger.error(f"Unknown error connecting to Jira, {unknown_error}!")
+            raise
 
     def check_connection(self) -> StatusResponse:
         """
-        Check connection to the handler.
+        Checks the status of the connection to the Salesforce API.
+
         Returns:
-            HandlerStatusResponse
+            StatusResponse: An object containing the success status and an error message if an error occurs.
         """
-
         response = StatusResponse(False)
 
         try:
-            self.api_resource_generator.check_connection()
+            connection = self.connect()
+            connection.myself()
             response.success = True
-        except Exception as e:
-            logger.error(f"Error connecting to Jira API: {e}!")
-            response.error_message = e
+        except (HTTPError, ValueError) as known_error:
+            logger.error(f'Connection check to Jira failed, {known_error}!')
+            response.error_message = str(known_error)
+        except Exception as unknown_error:
+            logger.error(f'Connection check to Jira failed due to an unknown error, {unknown_error}!')
+            response.error_message = str(unknown_error)
 
         self.is_connected = response.success
+
         return response
+
+    def native_query(self, query: str) -> Response:
+        """
+        Executes a native JQL query on Jira and returns the result.
+
+        Args:
+            query (Text): The JQL query to be executed.
+
+        Returns:
+            Response: A response object containing the result of the query or an error message.
+        """
+        connection = self.connect()
+
+        try:
+            results = connection.jql(query)
+            df = JiraIssuesTable(self).normalize(results['issues'])
+            response = Response(
+                RESPONSE_TYPE.TABLE,
+                df
+            )
+        except HTTPError as http_error:
+            logger.error(f'Error running query: {query} on Jira, {http_error}!')
+            response = Response(
+                RESPONSE_TYPE.ERROR,
+                error_code=0,
+                error_message=str(http_error)
+            )
+        except Exception as unknown_error:
+            logger.error(f'Error running query: {query} on Jira, {unknown_error}!')
+            response = Response(
+                RESPONSE_TYPE.ERROR,
+                error_code=0,
+                error_message=str(unknown_error)
+            )
+
+        return response

mindsdb/integrations/handlers/jira_handler/jira_tables.py

@@ -0,0 +1,229 @@
+from typing import List
+
+from atlassian import Jira
+import pandas as pd
+
+from mindsdb.integrations.libs.api_handler import APIResource
+from mindsdb.integrations.utilities.sql_utils import FilterCondition, SortColumn, FilterOperator
+from mindsdb.utilities import log
+
+
+logger = log.getLogger(__name__)
+
+
+class JiraProjectsTable(APIResource):
+    def list(
+        self,
+        conditions: List[FilterCondition] = None,
+        limit: int = None,
+        sort: List[SortColumn] = None,
+        targets: List[str] = None,
+        **kwargs
+    ) -> pd.DataFrame:
+        client: Jira = self.handler.connect()
+
+        projects = []
+        for condition in conditions:
+            if condition.column in ('id', 'key'): 
+                if condition.op == FilterOperator.EQUAL:
+                    projects = [client.get_project(condition.value)]
+                elif condition.op == FilterOperator.IN:
+                    projects = [client.get_project(project_id) for project_id in condition.value]
+                else:
+                    raise ValueError(f"Unsupported operator {condition.op} for column {condition.column}.")
+                condition.applied = True
+
+        if not projects:
+            projects = client.get_all_projects()
+
+        if projects:
+            projects_df = pd.DataFrame(projects)
+            projects_df = projects_df[self.get_columns()]
+        else:
+            projects_df = pd.DataFrame([], columns=self.get_columns())
+
+        return projects_df
+    
+    def get_columns(self) -> List[str]:
+        return [
+            "id",
+            "key",
+            "name",
+            "projectTypeKey",
+            "simplified",
+            "style",
+            "isPrivate",
+            "entityId",
+            "uuid",
+        ]
+    
+
+class JiraIssuesTable(APIResource):
+    def list(
+        self,
+        conditions: List[FilterCondition] = None,
+        limit: int = None,
+        sort: List[SortColumn] = None,
+        targets: List[str] = None,
+        **kwargs
+    ) -> pd.DataFrame:
+        client: Jira = self.handler.connect()
+
+        issues = []
+        for condition in conditions:
+            if condition.column in ('id', 'key'): 
+                if condition.op == FilterOperator.EQUAL:
+                    issues = [client.get_issue(condition.value)]
+                elif condition.op == FilterOperator.IN:
+                    issues = [client.get_issue(issue_id) for issue_id in condition.value]
+                else:
+                    raise ValueError(f"Unsupported operator {condition.op} for column {condition.column}.")
+                condition.applied = True
+
+            elif condition.column in ('project_id', 'project_key', 'project_name'):
+                if condition.op == FilterOperator.EQUAL:
+                    issues = client.get_all_project_issues(condition.value, limit=limit)
+                elif condition.op == FilterOperator.IN:
+                    for project_id in condition.value:
+                        issues.extend(client.get_all_project_issues(project_id, limit=limit))
+
+                condition.applied = True
+                
+        if not issues:
+            project_ids = [project['id'] for project in client.get_all_projects()]
+            for project_id in project_ids:
+                issues.extend(self._get_project_issues_with_limit(client, project_id, limit=limit, current_issues=issues))
+
+        if issues:
+            issues_df = self.normalize(issues)
+        else:
+            issues_df = pd.DataFrame([], columns=self.get_columns())
+
+        return issues_df
+    
+    def _get_project_issues_with_limit(self, client: Jira, project_id, limit=None, current_issues=None):
+        """
+        Helper to get issues from a project, respecting the limit.
+        """
+        if current_issues is None:
+            current_issues = []
+        if limit:
+            remaining = limit - len(current_issues)
+            if remaining <= 0:
+                return []
+            return client.get_all_project_issues(project_id, limit=remaining)
+        else:
+            return client.get_all_project_issues(project_id)
+
+    def normalize(self, issues: dict) -> pd.DataFrame:
+        issues_df = pd.json_normalize(issues)
+        issues_df.rename(
+            columns={
+                "fields.project.id": "project_id",
+                "fields.project.key": "project_key",
+                "fields.project.name": "project_name",
+                "fields.summary": "summary",
+                "fields.priority.name": "priority",
+                "fields.creator.displayName": "creator",
+                "fields.assignee.displayName": "assignee",
+                "fields.status.name": "status",
+            },
+            inplace=True
+        )
+        issues_df = issues_df[self.get_columns()]
+
+        return issues_df
+
+    def get_columns(self) -> List[str]:
+        return [
+            "id",
+            "key",
+            "project_id",
+            "project_key",
+            "project_name",
+            "summary",
+            "priority",
+            "creator",
+            "assignee",
+            "status",
+        ]
+        
+        
+class JiraGroupsTable(APIResource):
+    def list(
+        self,
+        conditions: List[FilterCondition] = None,
+        limit: int = None,
+        sort: List[SortColumn] = None,
+        targets: List[str] = None,
+        **kwargs
+    ) -> pd.DataFrame:
+        client: Jira = self.handler.connect()
+
+        if limit:
+            groups = client.get_groups(limit=limit)['groups']
+        else:
+            groups = client.get_groups()['groups']
+
+        if groups:
+            groups_df = pd.DataFrame(groups)
+            groups_df = groups_df[self.get_columns()]
+        else:
+            groups_df = pd.DataFrame([], columns=self.get_columns())
+
+        return groups_df
+
+    def get_columns(self) -> List[str]:
+        return [
+            "groupId",
+            "name",
+            "html",
+        ]
+
+
+class JiraUsersTable(APIResource):
+    def list(
+        self,
+        conditions: List[FilterCondition] = None,
+        limit: int = None,
+        sort: List[SortColumn] = None,
+        targets: List[str] = None,
+        **kwargs
+    ) -> pd.DataFrame:
+        client: Jira = self.handler.connect()
+
+        users = []
+        for condition in conditions:
+            if condition.column == 'accountId': 
+                if condition.op == FilterOperator.EQUAL:
+                    users = [client.user(account_id=condition.value)]
+                elif condition.op == FilterOperator.IN:
+                    users = [client.user(account_id=accountId) for accountId in condition.value]
+                else:
+                    raise ValueError(f"Unsupported operator {condition.op} for column {condition.column}.")
+                condition.applied = True
+
+        if not users:
+            if limit:
+                users = client.users_get_all(limit=limit)
+            else:
+                users = client.users_get_all()
+
+        if users:
+            users_df = pd.DataFrame(users)
+            users_df = users_df[self.get_columns()]
+        else:
+            users_df = pd.DataFrame([], columns=self.get_columns())
+
+        return users_df
+
+    def get_columns(self) -> List[str]:
+        return [
+            "accountId",
+            "accountType",
+            "emailAddress",
+            "displayName",
+            "active",
+            "timeZone",
+            "locale",
+        ]

mindsdb/integrations/handlers/jira_handler/requirements.txt

@@ -0,0 +1 @@
+atlassian-python-api

mindsdb/integrations/handlers/lightfm_handler/requirements.txt

@@ -1 +1,2 @@
 lightfm==1.17
+dataprep_ml==24.5.1.2

mindsdb/integrations/handlers/lightwood_handler/lightwood_handler.py

@@ -21,8 +21,6 @@ from mindsdb.utilities.functions import cast_row_types
 
 from .functions import run_finetune, run_learn
 
-IS_PY36 = sys.version_info[1] <= 6
-
 
 class NumpyJSONEncoder(json.JSONEncoder):
     """

mindsdb/integrations/handlers/lightwood_handler/requirements.txt

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

mindsdb/integrations/handlers/lindorm_handler/requirements.txt

@@ -1,2 +1,3 @@
 pyphoenix
 phoenixdb
+protobuf==3.20.3

mindsdb/integrations/handlers/ms_one_drive_handler/requirements.txt

@@ -0,0 +1,2 @@
+msal
+-r mindsdb/integrations/utilities/handlers/auth_utilities/microsoft/requirements.txt

mindsdb/integrations/handlers/ms_teams_handler/requirements.txt

@@ -1,2 +1,4 @@
 botframework-connector
-botbuilder-schema
+botbuilder-schema
+msal
+-r mindsdb/integrations/utilities/handlers/auth_utilities/microsoft/requirements.txt

mindsdb/integrations/handlers/openai_handler/openai_handler.py

@@ -9,6 +9,7 @@ import subprocess
 import concurrent.futures
 from typing import Text, Tuple, Dict, List, Optional, Any
 import openai
+from openai.types.fine_tuning import FineTuningJob
 from openai import OpenAI, AzureOpenAI, NotFoundError, AuthenticationError
 import numpy as np
 import pandas as pd
@@ -1116,7 +1117,7 @@ class OpenAIHandler(BaseMLEngine):
         }
         return {**ft_params, **extra_params}
 
-    def _ft_call(self, ft_params: Dict, client: OpenAI, hour_budget: int) -> Tuple[openai.types.fine_tuning.FineTuningJob, Text]:
+    def _ft_call(self, ft_params: Dict, client: OpenAI, hour_budget: int) -> Tuple[FineTuningJob, Text]:
         """
         Submit a fine-tuning job via the OpenAI API.
         This method handles requests to both the legacy and new endpoints.
@@ -1134,7 +1135,7 @@ class OpenAIHandler(BaseMLEngine):
             PendingFT: If the fine-tuning process is still pending.
 
         Returns:
-            Tuple[openai.types.fine_tuning.FineTuningJob, Text]: Fine-tuning stats and result file ID.
+            Tuple[FineTuningJob, Text]: Fine-tuning stats and result file ID.
         """
         ft_result = client.fine_tuning.jobs.create(
             **{k: v for k, v in ft_params.items() if v is not None}
@@ -1143,7 +1144,7 @@ class OpenAIHandler(BaseMLEngine):
         @retry_with_exponential_backoff(
             hour_budget=hour_budget,
         )
-        def _check_ft_status(job_id: Text) -> openai.types.fine_tuning.FineTuningJob:
+        def _check_ft_status(job_id: Text) -> FineTuningJob:
             """
             Check the status of a fine-tuning job via the OpenAI API.
 
@@ -1154,7 +1155,7 @@ class OpenAIHandler(BaseMLEngine):
                 PendingFT: If the fine-tuning process is still pending.
 
             Returns:
-                openai.types.fine_tuning.FineTuningJob: Fine-tuning stats.
+                FineTuningJob: Fine-tuning stats.
             """
             ft_retrieved = client.fine_tuning.jobs.retrieve(fine_tuning_job_id=job_id)
             if ft_retrieved.status in ('succeeded', 'failed', 'cancelled'):

mindsdb/integrations/handlers/snowflake_handler/requirements.txt

@@ -1,2 +1,2 @@
-snowflake-connector-python[pandas]==3.13.1
+snowflake-connector-python[pandas]==3.15.0
 snowflake-sqlalchemy==1.7.0

mindsdb/integrations/handlers/vertex_handler/requirements.txt

@@ -1 +1,2 @@
 google-cloud-aiplatform>=1.35.0
+-r mindsdb/integrations/utilities/handlers/auth_utilities/google/requirements.txt

mindsdb/integrations/handlers/youtube_handler/requirements.txt

@@ -1,2 +1,3 @@
 google-api-python-client
 youtube-transcript-api
+-r mindsdb/integrations/utilities/handlers/auth_utilities/google/requirements.txt

mindsdb/integrations/utilities/files/file_reader.py

@@ -9,8 +9,6 @@ from typing import List
 import filetype
 import pandas as pd
 from charset_normalizer import from_bytes
-from langchain_text_splitters import RecursiveCharacterTextSplitter
-import fitz  # pymupdf
 
 from mindsdb.utilities import log
 
@@ -298,6 +296,8 @@ class FileReader(FormatDetector):
 
     @staticmethod
     def read_txt(file_obj: BytesIO, name=None, **kwargs):
+        # the lib is heavy, so import it only when needed
+        from langchain_text_splitters import RecursiveCharacterTextSplitter
         file_obj = decode(file_obj)
 
         try:
@@ -326,6 +326,9 @@ class FileReader(FormatDetector):
 
     @staticmethod
     def read_pdf(file_obj: BytesIO, name=None, **kwargs):
+        # the libs are heavy, so import it only when needed
+        import fitz  # pymupdf
+        from langchain_text_splitters import RecursiveCharacterTextSplitter
 
         with fitz.open(stream=file_obj.read()) as pdf:  # open pdf
             text = chr(12).join([page.get_text() for page in pdf])

mindsdb/interfaces/agents/constants.py

@@ -4,8 +4,20 @@ from langchain.agents import AgentType
 from langchain_openai import OpenAIEmbeddings
 
 from types import MappingProxyType
-from mindsdb.integrations.handlers.openai_handler.constants import (
-    CHAT_MODELS as OPEN_AI_CHAT_MODELS,
+
+# the same as
+# from mindsdb.integrations.handlers.openai_handler.constants import CHAT_MODELS
+OPEN_AI_CHAT_MODELS = (
+    'gpt-3.5-turbo',
+    'gpt-3.5-turbo-16k',
+    'gpt-3.5-turbo-instruct',
+    'gpt-4',
+    'gpt-4-32k',
+    'gpt-4-1106-preview',
+    'gpt-4-0125-preview',
+    'gpt-4o',
+    'o3-mini',
+    'o1-mini'
 )
 
 SUPPORTED_PROVIDERS = {

mindsdb/interfaces/agents/langchain_agent.py

@@ -24,9 +24,6 @@ from langchain_core.messages.base import BaseMessage
 from langchain_core.prompts import PromptTemplate
 from langchain_core.tools import Tool
 
-from mindsdb.integrations.handlers.openai_handler.constants import (
-    CHAT_MODELS as OPEN_AI_CHAT_MODELS,
-)
 from mindsdb.integrations.libs.llm.utils import get_llm_config
 from mindsdb.integrations.utilities.handler_utils import get_api_key
 from mindsdb.integrations.utilities.rag.settings import DEFAULT_RAG_PROMPT_TEMPLATE
@@ -42,7 +39,8 @@ from .callback_handlers import LogCallbackHandler, ContextCaptureCallback
 from .langfuse_callback_handler import LangfuseCallbackHandler, get_skills
 from .safe_output_parser import SafeOutputParser
 
-from .constants import (
+from mindsdb.interfaces.agents.constants import (
+    OPEN_AI_CHAT_MODELS,
     DEFAULT_AGENT_TIMEOUT_SECONDS,
     DEFAULT_AGENT_TYPE,
     DEFAULT_EMBEDDINGS_MODEL_PROVIDER,