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

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.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)
+        self._register_table("projects", JiraProjectsTable(self))
+        self._register_table("issues", JiraIssuesTable(self))
+        self._register_table("groups", JiraGroupsTable(self))
+        self._register_table("users", JiraUsersTable(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/kinetica_handler/__init__.py

@@ -8,7 +8,6 @@ try:
 except Exception as e:
     Handler = None
     import_error = e
-from .__about__ import __version__ as version, __description__ as description
 
 
 title = 'Kinetica'

mindsdb/integrations/handlers/langchain_handler/langchain_handler.py

@@ -108,7 +108,7 @@ AI: {response}'''
         self.model_storage.json_set('args', args)
 
     @staticmethod
-    def create_validation(_, args: Dict=None, **kwargs):
+    def create_validation(_, args: Dict = None, **kwargs):
         if 'using' not in args:
             raise Exception("LangChain engine requires a USING clause! Refer to its documentation for more details.")
         else:
@@ -117,7 +117,7 @@ AI: {response}'''
             if not args.get('mode') == 'retrieval':
                 raise ValueError('Please provide a `prompt_template` for this engine.')
 
-    def predict(self, df: pd.DataFrame, args: Dict=None) -> pd.DataFrame:
+    def predict(self, df: pd.DataFrame, args: Dict = None) -> pd.DataFrame:
         """
         Dispatch is performed depending on the underlying model type. Currently, only the default text completion
         is supported.
@@ -125,7 +125,7 @@ AI: {response}'''
         pred_args = args['predict_params'] if args else {}
         args = self.model_storage.json_get('args')
         if 'prompt_template' not in args and 'prompt_template' not in pred_args:
-            raise ValueError(f"This model expects a `prompt_template`, please provide one.")
+            raise ValueError("This model expects a `prompt_template`, please provide one.")
         # Back compatibility for old models
         args['provider'] = args.get('provider', get_llm_provider(args))
         args['embedding_model_provider'] = args.get('embedding_model', get_embedding_model_provider(args))
@@ -155,7 +155,7 @@ AI: {response}'''
 
         return pd.DataFrame([resp.content], columns=[assistant_column])
 
-    def create_agent(self, df: pd.DataFrame, args: Dict=None, pred_args: Dict=None) -> AgentExecutor:
+    def create_agent(self, df: pd.DataFrame, args: Dict = None, pred_args: Dict = None) -> AgentExecutor:
         pred_args = pred_args if pred_args else {}
 
         # Set up tools.

mindsdb/integrations/handlers/langchain_handler/tools.py

@@ -1,6 +1,5 @@
 import tiktoken
-
-from typing import Callable, Dict
+from typing import Callable
 
 from mindsdb_sql_parser import parse_sql
 from mindsdb_sql_parser.ast import Insert
@@ -13,21 +12,18 @@ from langchain.chains.llm import LLMChain
 from langchain.chains.combine_documents.stuff import StuffDocumentsChain
 from langchain.chains import ReduceDocumentsChain, MapReduceDocumentsChain
 
-from mindsdb.integrations.utilities.rag.rag_pipeline_builder import RAG
-from mindsdb.integrations.utilities.rag.settings import RAGPipelineModel, VectorStoreType, DEFAULT_COLLECTION_NAME
-from mindsdb.interfaces.skills.skill_tool import skill_tool, SkillType
-from mindsdb.interfaces.storage import db
+from mindsdb.interfaces.skills.skill_tool import skill_tool
 from mindsdb.utilities import log
 from langchain_core.prompts import PromptTemplate
 from langchain_core.tools import Tool
 from langchain_text_splitters import CharacterTextSplitter
 
 logger = log.getLogger(__name__)
-from mindsdb.interfaces.storage.db import KnowledgeBase
-from mindsdb.utilities import log
 
 # Individual tools
 # Note: all tools are defined in a closure to pass required args (apart from LLM input) through it, as custom tools don't allow custom field assignment.  # noqa
+
+
 def get_exec_call_tool(llm, executor, model_kwargs) -> Callable:
     def mdb_exec_call_tool(query: str) -> str:
         try:
@@ -50,6 +46,7 @@ def get_exec_call_tool(llm, executor, model_kwargs) -> Callable:
         return data
     return mdb_exec_call_tool
 
+
 def get_exec_metadata_tool(llm, executor, model_kwargs) -> Callable:
     def mdb_exec_metadata_call(query: str) -> str:
         try:
@@ -80,9 +77,9 @@ def get_exec_metadata_tool(llm, executor, model_kwargs) -> Callable:
                         data = f'Metadata for table {table_name}:\n'
                     fields = handler.get_columns(table_name).data_frame['Field'].to_list()
                     types = handler.get_columns(table_name).data_frame['Type'].to_list()
-                    data += f'List of columns and types:\n'
+                    data += 'List of columns and types:\n'
                     data += '\n'.join([f'\tColumn: `{field}`\tType: `{typ}`' for field, typ in zip(fields, types)])
-                except:
+                except BaseException:
                     data = f'Table {table_name} not found.'
         except Exception as e:
             data = f"mindsdb tool failed with error:\n{str(e)}"  # let the agent know
@@ -93,6 +90,7 @@ def get_exec_metadata_tool(llm, executor, model_kwargs) -> Callable:
         return data
     return mdb_exec_metadata_call
 
+
 def get_mdb_write_tool(executor) -> Callable:
     def mdb_write_call(query: str) -> str:
         try:
@@ -105,6 +103,7 @@ def get_mdb_write_tool(executor) -> Callable:
             return f"mindsdb write tool failed with error:\n{str(e)}"
     return mdb_write_call
 
+
 def _setup_standard_tools(tools, llm, model_kwargs):
     executor = skill_tool.get_command_executor()
 

mindsdb/integrations/handlers/leonardoai_handler/__init__.py

@@ -2,7 +2,7 @@ from mindsdb.integrations.libs.const import HANDLER_TYPE
 
 from .__about__ import __version__ as version, __description__ as description
 try:
-    from .leonardo_ai_handler import  LeonardoAIHandler as Handler
+    from .leonardo_ai_handler import LeonardoAIHandler as Handler
     import_error = None
 except Exception as e:
     Handler = None

mindsdb/integrations/handlers/lightfm_handler/requirements.txt

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

mindsdb/integrations/handlers/lightwood_handler/functions.py

@@ -9,13 +9,12 @@ from pathlib import Path
 import lightwood
 import pandas as pd
 import requests
-from lightwood.api.types import JsonAI, ProblemDefinition
+from lightwood.api.types import JsonAI
 from pandas.core.frame import DataFrame
 
 import mindsdb.utilities.profiler as profiler
 from mindsdb.integrations.libs.const import PREDICTOR_STATUS
 from mindsdb.integrations.utilities.utils import format_exception_error
-from mindsdb.interfaces.model.functions import get_model_records
 from mindsdb.interfaces.storage import db
 from mindsdb.interfaces.storage.fs import RESOURCE_GROUP, FileStorage
 from mindsdb.interfaces.storage.json import get_json_storage
@@ -26,6 +25,7 @@ from .utils import brack_to_mod, rep_recur, unpack_jsonai_old_args
 
 logger = log.getLogger(__name__)
 
+
 def create_learn_mark():
     if os.name == 'posix':
         p = Path(tempfile.gettempdir()).joinpath('mindsdb/learn_processes/')

mindsdb/integrations/handlers/lightwood_handler/lightwood_handler.py

@@ -1,6 +1,5 @@
 import copy
 import json
-import sys
 from datetime import datetime
 from functools import lru_cache
 from typing import Dict, Optional
@@ -21,8 +20,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/lightwood_handler/tests/test_lightwood_handler.py

@@ -1,3 +1,12 @@
+import mindsdb.interfaces.storage.db as db
+from mindsdb.integrations.libs.response import RESPONSE_TYPE
+from mindsdb.interfaces.model.model_controller import ModelController
+from mindsdb.interfaces.storage.fs import FsStore
+from mindsdb.integrations.handlers.lightwood_handler.lightwood_handler.lightwood_handler import LightwoodHandler
+from mindsdb.interfaces.database.integrations import integration_controller
+from mindsdb.integrations.utilities.test_utils import PG_HANDLER_NAME, PG_CONNECTION_DATA
+from mindsdb.utilities.config import Config
+from mindsdb.migrations import migrate
 import os
 import time
 import unittest
@@ -7,18 +16,9 @@ temp_dir = tempfile.mkdtemp(dir='/tmp/', prefix='lightwood_handler_test_')
 os.environ['MINDSDB_STORAGE_DIR'] = os.environ.get('MINDSDB_STORAGE_DIR', temp_dir)
 os.environ['MINDSDB_DB_CON'] = 'sqlite:///' + os.path.join(os.environ['MINDSDB_STORAGE_DIR'], 'mindsdb.sqlite3.db') + '?check_same_thread=False&timeout=30'
 
-from mindsdb.migrations import migrate
 migrate.migrate_to_head()
 
-from mindsdb.utilities.config import Config
-from mindsdb.integrations.utilities.test_utils import HandlerControllerMock, PG_HANDLER_NAME, PG_CONNECTION_DATA
-from mindsdb.interfaces.database.integrations import integration_controller
-from mindsdb.integrations.handlers.lightwood_handler.lightwood_handler.lightwood_handler import LightwoodHandler
 # from mindsdb.integrations.handlers.lightwood_handler.lightwood_handler.utils import load_predictor
-from mindsdb.interfaces.storage.fs import FsStore
-from mindsdb.interfaces.model.model_controller import ModelController
-from mindsdb.integrations.libs.response import RESPONSE_TYPE
-import mindsdb.interfaces.storage.db as db
 
 
 # TODO: drop all models and tables when closing tests
@@ -96,7 +96,7 @@ class LightwoodHandlerTest(unittest.TestCase):
         self.assertTrue(response.type == RESPONSE_TYPE.OK)
 
     def test_04_query_predictor_single_where_condition(self):
-        time.sleep(120) # TODO 
+        time.sleep(120)  # TODO
         query = f"""
             SELECT target
             from {self.test_model_1}
@@ -255,4 +255,4 @@ class LightwoodHandlerTest(unittest.TestCase):
 
 
 if __name__ == "__main__":
-    unittest.main(failfast=True)
+    unittest.main(failfast=True)

mindsdb/integrations/handlers/lindorm_handler/requirements.txt

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