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

mindsdb/api/http/namespaces/config.py

@@ -27,33 +27,41 @@ class GetConfig(Resource):
     @api_endpoint_metrics('GET', '/config')
     def get(self):
         config = Config()
-        return {
+        resp = {
             'auth': {
                 'http_auth_enabled': config['auth']['http_auth_enabled']
             }
         }
+        for key in ['default_llm', 'default_embedding_model']:
+            value = config.get(key)
+            if value is not None:
+                resp[key] = value
+        return resp
 
     @ns_conf.doc('put_config')
     @api_endpoint_metrics('PUT', '/config')
     def put(self):
         data = request.json
 
-        unknown_argumens = list(set(data.keys()) - {'auth'})
-        if len(unknown_argumens) > 0:
+        allowed_arguments = {'auth', 'default_llm', 'default_embedding_model'}
+        unknown_arguments = list(set(data.keys()) - allowed_arguments)
+        if len(unknown_arguments) > 0:
             return http_error(
                 HTTPStatus.BAD_REQUEST, 'Wrong arguments',
-                f'Unknown argumens: {unknown_argumens}'
+                f'Unknown argumens: {unknown_arguments}'
             )
 
+        nested_keys_to_validate = {'auth'}
         for key in data.keys():
-            unknown_argumens = list(
-                set(data[key].keys()) - set(Config()[key].keys())
-            )
-            if len(unknown_argumens) > 0:
-                return http_error(
-                    HTTPStatus.BAD_REQUEST, 'Wrong arguments',
-                    f'Unknown argumens: {unknown_argumens}'
+            if key in nested_keys_to_validate:
+                unknown_arguments = list(
+                    set(data[key].keys()) - set(Config()[key].keys())
                 )
+                if len(unknown_arguments) > 0:
+                    return http_error(
+                        HTTPStatus.BAD_REQUEST, 'Wrong arguments',
+                        f'Unknown argumens: {unknown_arguments}'
+                    )
 
         Config().update(data)
 

mindsdb/api/http/namespaces/tree.py

@@ -94,7 +94,7 @@ class GetLeaf(Resource):
                 } for key, val in schemas.items()]
         elif db['type'] == 'system':
             system_db = ca.database_controller.get_system_db(db_name)
-            tables = system_db.get_tables()
+            tables = system_db.get_tree_tables()
             tables = [{
                 'name': table.name,
                 'class': table.kind,

mindsdb/api/http/start.py

@@ -1,3 +1,6 @@
+import gc
+gc.disable()
+
 from flask import Flask
 from waitress import serve
 
@@ -8,6 +11,8 @@ from mindsdb.utilities.config import config
 from mindsdb.utilities.functions import init_lexer_parsers
 from mindsdb.integrations.libs.ml_exec_base import process_cache
 
+gc.enable()
+
 logger = log.getLogger(__name__)
 
 
@@ -26,7 +31,7 @@ def start(verbose, no_studio, app: Flask = None):
     process_cache.init()
 
     if server_type == "waitress":
-        logger.debug("Serving HTTP app with waitress..")
+        logger.debug("Serving HTTP app with waitress...")
         serve(
             app,
             host='*' if host in ('', '0.0.0.0') else host,
@@ -34,7 +39,7 @@ def start(verbose, no_studio, app: Flask = None):
             **server_config
         )
     elif server_type == "flask":
-        logger.debug("Serving HTTP app with flask..")
+        logger.debug("Serving HTTP app with flask...")
         # that will 'disable access' log in console
 
         app.run(debug=False, port=port, host=host, **server_config)

mindsdb/api/mysql/mysql_proxy/mysql_proxy.py

@@ -32,13 +32,11 @@ from mindsdb.api.mysql.mysql_proxy.data_types.mysql_datum import Datum
 
 import mindsdb.utilities.hooks as hooks
 import mindsdb.utilities.profiler as profiler
+from mindsdb.utilities.sql import clear_sql
 from mindsdb.api.mysql.mysql_proxy.classes.client_capabilities import ClentCapabilities
 from mindsdb.api.mysql.mysql_proxy.classes.server_capabilities import (
     server_capabilities,
 )
-from mindsdb.api.mysql.mysql_proxy.classes.sql_statement_parser import (
-    SqlStatementParser,
-)
 from mindsdb.api.executor.controllers import SessionController
 from mindsdb.api.mysql.mysql_proxy.data_types.mysql_packet import Packet
 from mindsdb.api.mysql.mysql_proxy.data_types.mysql_packets import (
@@ -85,7 +83,7 @@ from mindsdb.api.mysql.mysql_proxy.utilities.lightwood_dtype import dtype
 from mindsdb.utilities import log
 from mindsdb.utilities.config import config
 from mindsdb.utilities.context import context as ctx
-from mindsdb.utilities.otel.metric_handlers import get_query_request_counter
+from mindsdb.utilities.otel import increment_otel_query_request_counter
 from mindsdb.utilities.wizards import make_ssl_cert
 
 logger = log.getLogger(__name__)
@@ -560,9 +558,7 @@ class MysqlProxy(SocketServer.BaseRequestHandler):
             )
 
         # Increment the counter and include metadata in attributes
-        metadata = ctx.metadata(query=sql)
-        query_request_counter = get_query_request_counter()
-        query_request_counter.add(1, metadata)
+        increment_otel_query_request_counter(ctx.get_metadata(query=sql))
 
         return resp
 
@@ -741,7 +737,7 @@ class MysqlProxy(SocketServer.BaseRequestHandler):
             try:
                 if p.type.value == COMMANDS.COM_QUERY:
                     sql = self.decode_utf(p.sql.value)
-                    sql = SqlStatementParser.clear_sql(sql)
+                    sql = clear_sql(sql)
                     logger.debug(f'Incoming query: {sql}')
                     profiler.set_meta(
                         query=sql, api="mysql", environment=config.get("environment")

mindsdb/api/mysql/mysql_proxy/utilities/exceptions.py

@@ -12,7 +12,3 @@ class ErSqlSyntaxError(SqlApiException):
 
 class ErWrongCharset(SqlApiException):
     err_code = ERR.ER_UNKNOWN_CHARACTER_SET
-
-
-class ErParseError(SqlApiException):
-    err_code = ERR.ER_PARSE_ERROR

mindsdb/api/postgres/postgres_proxy/postgres_packets/postgres_message_formats.py

@@ -1,6 +1,5 @@
 from typing import BinaryIO, Sequence, Dict, Type
 
-from mindsdb.api.mysql.mysql_proxy.classes.sql_statement_parser import SqlStatementParser
 from mindsdb.api.postgres.postgres_proxy.postgres_packets.postgres_fields import PostgresField
 from mindsdb.api.postgres.postgres_proxy.postgres_packets.postgres_message import PostgresMessage
 from mindsdb.api.postgres.postgres_proxy.postgres_packets.postgres_message_identifiers import \
@@ -8,6 +7,7 @@ from mindsdb.api.postgres.postgres_proxy.postgres_packets.postgres_message_ident
 
 from mindsdb.api.postgres.postgres_proxy.postgres_packets.postgres_packets import PostgresPacketReader
 from mindsdb.api.postgres.postgres_proxy.utilities import strip_null_byte
+from mindsdb.utilities.sql import clear_sql
 
 
 # All docstrings for Messages are taken from
@@ -507,7 +507,7 @@ class Query(PostgresMessage):
             raise Exception(f'SQL contains non {encoding} values: {self.sql}')
         # Remove null bytes from end of sql statement. This is important.
         sql = strip_null_byte(sql)
-        sql = SqlStatementParser.clear_sql(sql)
+        sql = clear_sql(sql)
         return sql
 
 

mindsdb/integrations/handlers/bigquery_handler/requirements.txt

@@ -1,2 +1,3 @@
 google-cloud-bigquery[pandas]
 sqlalchemy-bigquery
+-r mindsdb/integrations/utilities/handlers/auth_utilities/google/requirements.txt

mindsdb/integrations/handlers/chromadb_handler/requirements.txt

@@ -1 +1,2 @@
 chromadb~=0.6.3
+onnxruntime==1.20.1 # 1.21.0 (latest as of April 10, 2025) causes issues in Windows

mindsdb/integrations/handlers/gmail_handler/requirements.txt

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

mindsdb/integrations/handlers/google_analytics_handler/requirements.txt

@@ -1,2 +1,3 @@
 google-api-python-client
-google-analytics-admin
+google-analytics-admin
+google-auth

mindsdb/integrations/handlers/google_books_handler/requirements.txt

@@ -1,2 +1,2 @@
 google-api-python-client
-google-auth-httplib2
+google-auth

mindsdb/integrations/handlers/google_calendar_handler/requirements.txt

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

mindsdb/integrations/handlers/google_content_shopping_handler/requirements.txt

@@ -1,2 +1,2 @@
 google-api-python-client
-google-auth-httplib2
+google-auth

mindsdb/integrations/handlers/google_fit_handler/requirements.txt

@@ -2,3 +2,5 @@ tzlocal
 google
 google-api-python-client
 tzlocal
+google-auth
+google-auth-oauthlib

mindsdb/integrations/handlers/google_search_handler/requirements.txt

@@ -1,2 +1,2 @@
 google-api-python-client
-google-auth-httplib2
+google-auth

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