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

mindsdb/interfaces/query_context/context_controller.py

@@ -15,6 +15,7 @@ from mindsdb.utilities.cache import get_cache
 
 from mindsdb.interfaces.storage import db
 from mindsdb.utilities.context import context as ctx
+from mindsdb.utilities.config import config
 
 from .last_query import LastQuery
 
@@ -24,9 +25,12 @@ class RunningQuery:
       Query in progres
     """
 
+    OBJECT_TYPE = 'query'
+
     def __init__(self, record: db.Queries):
         self.record = record
         self.sql = record.sql
+        self.database = record.database or config.get('default_project')
 
     def get_partition_query(self, step_num: int, query: Select) -> Select:
         """
@@ -67,6 +71,44 @@ class RunningQuery:
 
         return query
 
+    def get_info(self):
+        record = self.record
+        return {
+            'id': record.id,
+            'sql': record.sql,
+            'database': record.database,
+            'started_at': record.started_at,
+            'finished_at': record.finished_at,
+            'parameters': record.parameters,
+            'context': record.context,
+            'processed_rows': record.processed_rows,
+            'error': record.error,
+            'updated_at': record.updated_at,
+        }
+
+    def add_to_task(self):
+
+        task_record = db.Tasks(
+            company_id=ctx.company_id,
+            user_class=ctx.user_class,
+
+            object_type=self.OBJECT_TYPE,
+            object_id=self.record.id,
+        )
+        db.session.add(task_record)
+        db.session.commit()
+
+    def remove_from_task(self):
+        task = db.Tasks.query.filter(
+            db.Tasks.object_type == self.OBJECT_TYPE,
+            db.Tasks.object_id == self.record.id,
+            db.Tasks.company_id == ctx.company_id,
+        ).first()
+
+        if task is not None:
+            db.session.delete(task)
+            db.session.commit()
+
     def set_params(self, params: dict):
         """
             Store parameters of the step which is about to be split into partitions
@@ -126,14 +168,21 @@ class RunningQuery:
 
         db.session.commit()
 
-    def clear_error(self):
+    def mark_as_run(self):
         """
-            Reset error of the query in database
+            Mark query as running and reset error of the query
         """
+        if self.record.finished_at is not None:
+            raise RuntimeError('The query already finished')
 
-        if self.record.error is not None:
+        if self.record.started_at is None:
+            self.record.started_at = dt.datetime.now()
+            db.session.commit()
+        elif self.record.error is not None:
             self.record.error = None
             db.session.commit()
+        else:
+            raise RuntimeError('The query might be running already')
 
     def get_state(self) -> dict:
         """
@@ -448,7 +497,7 @@ class QueryContextController:
             raise RuntimeError(f'Query not found: {query_id}')
         return RunningQuery(rec)
 
-    def create_query(self, query: ASTNode) -> RunningQuery:
+    def create_query(self, query: ASTNode, database: str = None) -> RunningQuery:
         """
            Create a new running query from AST query
         """
@@ -463,6 +512,7 @@ class QueryContextController:
 
         rec = db.Queries(
             sql=str(query),
+            database=database,
             company_id=ctx.company_id,
         )
 
@@ -479,17 +529,7 @@ class QueryContextController:
             db.Queries.company_id == ctx.company_id
         )
         return [
-            {
-                'id': record.id,
-                'sql': record.sql,
-                'started_at': record.started_at,
-                'finished_at': record.finished_at,
-                'parameters': record.parameters,
-                'context': record.context,
-                'processed_rows': record.processed_rows,
-                'error': record.error,
-                'updated_at': record.updated_at,
-            }
+            RunningQuery(record).get_info()
             for record in query
         ]
 

mindsdb/interfaces/query_context/query_task.py

@@ -0,0 +1,19 @@
+from mindsdb.api.executor.sql_query import SQLQuery
+from mindsdb.interfaces.query_context.context_controller import query_context_controller
+from mindsdb.api.executor.controllers.session_controller import SessionController
+from mindsdb.interfaces.tasks.task import BaseTask
+
+
+class QueryTask(BaseTask):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.query_id = self.object_id
+
+    def run(self, stop_event):
+
+        try:
+            session = SessionController()
+            SQLQuery(None, query_id=self.query_id, session=session, stop_event=stop_event)
+        finally:
+            # clear task
+            query_context_controller.get_query(self.query_id).remove_from_task()

mindsdb/interfaces/skills/sql_agent.py

@@ -1,4 +1,3 @@
-
 import re
 import csv
 import inspect
@@ -13,6 +12,7 @@ from mindsdb.utilities import log
 from mindsdb.utilities.context import context as ctx
 from mindsdb.integrations.utilities.query_traversal import query_traversal
 from mindsdb.integrations.libs.response import INF_SCHEMA_COLUMNS_NAMES
+from mindsdb.api.mysql.mysql_proxy.libs.constants.mysql import MYSQL_DATA_TYPE
 
 logger = log.getLogger(__name__)
 
@@ -253,7 +253,7 @@ class SQLAgent:
         for table in all_tables:
             key = f"{ctx.company_id}_{table}_info"
             table_info = self._cache.get(key) if self._cache else None
-            if table_info is None:
+            if True or table_info is None:
                 table_info = self._get_single_table_info(table)
                 if self._cache:
                     self._cache.set(key, table_info)
@@ -276,19 +276,41 @@ class SQLAgent:
         dn = self._command_executor.session.datahub.get(integration)
 
         fields, dtypes = [], []
-        for df in dn.get_table_columns_df(table_name, schema_name):
-            df_records = df.to_dict(orient='records')
-            fields.append(df_records[INF_SCHEMA_COLUMNS_NAMES.COLUMN_NAME])
-            if df_records[INF_SCHEMA_COLUMNS_NAMES.MYSQL_DATA_TYPE] is not None:
-                dtypes.append(df_records[INF_SCHEMA_COLUMNS_NAMES.MYSQL_DATA_TYPE].value)
-            else:
-                dtypes.append(df_records[INF_SCHEMA_COLUMNS_NAMES.DATA_TYPE])
+        try:
+            df = dn.get_table_columns_df(table_name, schema_name)
+            if not isinstance(df, pd.DataFrame) or df.empty:
+                logger.warning(f"Received empty or invalid DataFrame for table columns of {table_str}")
+                return f"Table named `{table_str}`:\n [No column information available]"
+
+            fields = df[INF_SCHEMA_COLUMNS_NAMES.COLUMN_NAME].to_list()
+            dtypes = [
+                mysql_data_type.value if isinstance(mysql_data_type, MYSQL_DATA_TYPE) else (data_type or 'UNKNOWN')
+                for mysql_data_type, data_type
+                in zip(
+                    df[INF_SCHEMA_COLUMNS_NAMES.MYSQL_DATA_TYPE],
+                    df[INF_SCHEMA_COLUMNS_NAMES.DATA_TYPE]
+                )
+            ]
+        except Exception as e:
+            logger.error(f"Failed processing column info for {table_str}: {e}", exc_info=True)
+            raise ValueError(f"Failed to process column info for {table_str}") from e
+
+        if not fields:
+            logger.error(f"Could not extract column fields for {table_str}.")
+            return f"Table named `{table_str}`:\n [Could not extract column information]"
+
+        try:
+            sample_rows_info = self._get_sample_rows(table_str, fields)
+        except Exception as e:
+            logger.warning(f"Could not get sample rows for {table_str}: {e}")
+            sample_rows_info = "\n\t [error] Couldn't retrieve sample rows!"
 
         info = f'Table named `{table_str}`:\n'
         info += f"\nSample with first {self._sample_rows_in_table_info} rows from table {table_str} in CSV format (dialect is 'excel'):\n"
-        info += self._get_sample_rows(table_str, fields) + "\n"
+        info += sample_rows_info + "\n"
         info += '\nColumn data types: ' + ",\t".join(
-            [f'\n`{field}` : `{dtype}`' for field, dtype in zip(fields, dtypes)]) + '\n'  # noqa
+            [f'\n`{field}` : `{dtype}`' for field, dtype in zip(fields, dtypes)]
+        ) + '\n'
         return info
 
     def _get_sample_rows(self, table: str, fields: List[str]) -> str:

mindsdb/interfaces/storage/db.py

@@ -571,9 +571,9 @@ class Queries(Base):
     company_id: int = Column(Integer, nullable=True)
 
     sql: str = Column(String, nullable=False)
-    # step_data: JSON = Column(JSON, nullable=True)
+    database: str = Column(String, nullable=True)
 
-    started_at: datetime.datetime = Column(DateTime, default=datetime.datetime.now)
+    started_at: datetime.datetime = Column(DateTime)
     finished_at: datetime.datetime = Column(DateTime)
 
     parameters = Column(JSON, default={})

mindsdb/interfaces/tasks/task_monitor.py

@@ -2,6 +2,7 @@ import datetime as dt
 import os
 import socket
 import time
+from threading import Event
 
 import sqlalchemy as sa
 
@@ -22,7 +23,7 @@ class TaskMonitor:
     def __init__(self):
         self._active_tasks = {}
 
-    def start(self):
+    def start(self, stop_event: Event = None):
         config = Config()
         db.init()
         self.config = config
@@ -42,6 +43,9 @@ class TaskMonitor:
                 logger.error(e)
                 db.session.rollback()
 
+            if stop_event is not None and stop_event.is_set():
+                return
+
     def stop_all_tasks(self):
 
         active_tasks = list(self._active_tasks.keys())

mindsdb/interfaces/tasks/task_thread.py

@@ -6,6 +6,7 @@ from mindsdb.utilities import log
 
 from mindsdb.interfaces.triggers.trigger_task import TriggerTask
 from mindsdb.interfaces.chatbot.chatbot_task import ChatBotTask
+from mindsdb.interfaces.query_context.query_task import QueryTask
 
 logger = log.getLogger(__name__)
 
@@ -28,6 +29,7 @@ class TaskThread(threading.Thread):
         ctx.company_id = task_record.company_id
         if task_record.user_class is not None:
             ctx.user_class = task_record.user_class
+        ctx.task_id = task_record.id
 
         self.object_type = task_record.object_type
         self.object_id = task_record.object_id
@@ -43,6 +45,10 @@ class TaskThread(threading.Thread):
                 bot = ChatBotTask(self.task_id, self.object_id)
                 bot.run(self._stop_event)
 
+            elif self.object_type == 'query':
+                query = QueryTask(self.task_id, self.object_id)
+                query.run(self._stop_event)
+
         except Exception:
             logger.error(traceback.format_exc())
             task_record.last_error = str(traceback.format_exc())

mindsdb/migrations/migrate.py

@@ -47,7 +47,5 @@ def migrate_to_head():
 if __name__ == "__main__":
     # have to import this because
     # all env initialization happens here
-    from mindsdb.utilities.config import Config as MDBConfig
-    MDBConfig()
     db.init()
     migrate_to_head()

mindsdb/migrations/versions/2025-04-22_53502b6d63bf_query_database.py

@@ -0,0 +1,27 @@
+"""query_database
+
+Revision ID: 53502b6d63bf
+Revises: fda503400e43
+Create Date: 2025-04-22 16:30:15.139978
+
+"""
+from alembic import op
+import sqlalchemy as sa
+import mindsdb.interfaces.storage.db  # noqa
+
+
+# revision identifiers, used by Alembic.
+revision = '53502b6d63bf'
+down_revision = 'fda503400e43'
+branch_labels = None
+depends_on = None
+
+
+def upgrade():
+    with op.batch_alter_table('queries', schema=None) as batch_op:
+        batch_op.add_column(sa.Column('database', sa.String(), nullable=True))
+
+
+def downgrade():
+    with op.batch_alter_table('queries', schema=None) as batch_op:
+        batch_op.drop_column('database')

mindsdb/utilities/config.py

@@ -143,7 +143,8 @@ class Config:
             'auth': {
                 'http_auth_enabled': False,
                 "http_permanent_session_lifetime": datetime.timedelta(days=31),
-                "username": "mindsdb"
+                "username": "mindsdb",
+                "password": ""
             },
             "logging": {
                 "handlers": {
@@ -230,7 +231,9 @@ class Config:
             "tasks": {
                 "disable": False
             },
-            "default_project": "mindsdb"
+            "default_project": "mindsdb",
+            "default_llm": {},
+            "default_embedding_model": {}
         }
         # endregion
 
@@ -369,6 +372,15 @@ class Config:
         if os.environ.get('MINDSDB_DEFAULT_PROJECT', '') != '':
             self._env_config['default_project'] = os.environ['MINDSDB_DEFAULT_PROJECT'].lower()
 
+        if os.environ.get('MINDSDB_DEFAULT_LLM_API_KEY', '') != '':
+            self._env_config['default_llm'] = {
+                'api_key': os.environ['MINDSDB_DEFAULT_LLM_API_KEY']
+            }
+        if os.environ.get('MINDSDB_DEFAULT_EMBEDDING_MODEL_API_KEY', '') != '':
+            self._env_config['default_embedding_model'] = {
+                'api_key': os.environ['MINDSDB_DEFAULT_EMBEDDING_MODEL_API_KEY']
+            }
+
     def parse_cmd_args(self) -> None:
         """Collect cmd args to self._cmd_args (accessable as self.cmd_args)
         """
@@ -448,7 +460,7 @@ class Config:
         """
         updated = self.fetch_auto_config()
         if updated:
-            self.init_config()
+            self.merge_configs()
 
     def merge_configs(self) -> None:
         """Merge multiple configs to one.

mindsdb/utilities/context.py

@@ -18,6 +18,7 @@ class Context:
             'user_id': None,
             'company_id': None,
             'session_id': "",
+            'task_id': None,
             'user_class': 0,
             'profiling': {
                 'level': 0,
@@ -53,7 +54,7 @@ class Context:
     def load(self, storage: dict) -> None:
         self._storage.set(storage)
 
-    def metadata(self, **kwargs) -> dict:
+    def get_metadata(self, **kwargs) -> dict:
         return {
             'user_id': self.user_id or "",
             'company_id': self.company_id or "",

mindsdb/utilities/functions.py

@@ -7,7 +7,6 @@ import textwrap
 from functools import wraps
 from collections.abc import Callable
 
-import requests
 from cryptography.fernet import Fernet
 from mindsdb_sql_parser.ast import Identifier
 
@@ -72,41 +71,6 @@ def mark_process(name: str, custom_mark: str = None) -> Callable:
     return mark_process_wrapper
 
 
-def get_versions_where_predictors_become_obsolete():
-    """ Get list of MindsDB versions in which predictors should be retrained
-        Returns:
-            list of str or False
-    """
-    versions_for_updating_predictors = []
-    try:
-        try:
-            res = requests.get(
-                'https://mindsdb-cloud-public-service-files.s3.us-east-2.amazonaws.com/version_for_updating_predictors.txt',
-                timeout=0.5
-            )
-        except (ConnectionError, requests.exceptions.ConnectionError) as e:
-            logger.error(f'Is no connection. {e}')
-            raise
-        except Exception as e:
-            logger.error(f'Is something wrong with getting version_for_updating_predictors.txt: {e}')
-            raise
-
-        if res.status_code != 200:
-            logger.error(f'Cant get version_for_updating_predictors.txt: returned status code = {res.status_code}')
-            raise
-
-        try:
-            versions_for_updating_predictors = res.text.replace(' \t\r', '').split('\n')
-        except Exception as e:
-            logger.error(f'Cant decode version_for_updating_predictors.txt: {e}')
-            raise
-    except Exception:
-        return False, versions_for_updating_predictors
-
-    versions_for_updating_predictors = [x for x in versions_for_updating_predictors if len(x) > 0]
-    return True, versions_for_updating_predictors
-
-
 def init_lexer_parsers():
     from mindsdb_sql_parser.lexer import MindsDBLexer
     from mindsdb_sql_parser.parser import MindsDBParser

mindsdb/utilities/langfuse.py

@@ -1,11 +1,12 @@
 import os
 import typing
+from typing import TYPE_CHECKING
 
 from mindsdb.utilities import log
-from langfuse import Langfuse
-from langfuse.client import StatefulSpanClient
-from langfuse.callback import CallbackHandler
-from langfuse.api.resources.commons.errors.not_found_error import NotFoundError as TraceNotFoundError
+
+if TYPE_CHECKING:
+    from langfuse.callback import CallbackHandler
+    from langfuse.client import StatefulSpanClient
 
 logger = log.getLogger(__name__)
 
@@ -98,6 +99,12 @@ class LangfuseClientWrapper:
         logger.debug(f"LANGFUSE_TIMEOUT: {LANGFUSE_TIMEOUT}")
         logger.debug(f"LANGFUSE_SAMPLE_RATE: {LANGFUSE_SAMPLE_RATE * 100}%")
 
+        try:
+            from langfuse import Langfuse
+        except ImportError:
+            logger.error("Langfuse is not installed. Please install it with `pip install langfuse`.")
+            return
+
         self.client = Langfuse(
             public_key=public_key,
             secret_key=secret_key,
@@ -164,7 +171,7 @@ class LangfuseClientWrapper:
 
     def start_span(self,
                    name: str,
-                   input: typing.Optional[typing.Any] = None) -> typing.Optional[StatefulSpanClient]:
+                   input: typing.Optional[typing.Any] = None) -> typing.Optional['StatefulSpanClient']:
         """
         Create span. If Langfuse is disabled, nothing will be done.
 
@@ -180,7 +187,7 @@ class LangfuseClientWrapper:
         return self.trace.span(name=name, input=input)
 
     def end_span_stream(self,
-                        span: typing.Optional[StatefulSpanClient] = None) -> None:
+                        span: typing.Optional['StatefulSpanClient'] = None) -> None:
         """
         End span. If Langfuse is disabled, nothing will happen.
         Args:
@@ -195,7 +202,7 @@ class LangfuseClientWrapper:
         self.trace.update()
 
     def end_span(self,
-                 span: typing.Optional[StatefulSpanClient] = None,
+                 span: typing.Optional['StatefulSpanClient'] = None,
                  output: typing.Optional[typing.Any] = None) -> None:
         """
         End trace. If Langfuse is disabled, nothing will be done.
@@ -227,7 +234,7 @@ class LangfuseClientWrapper:
         except Exception as e:
             logger.error(f'Something went wrong while processing Langfuse trace {self.trace.id}: {str(e)}')
 
-    def get_langchain_handler(self) -> typing.Optional[CallbackHandler]:
+    def get_langchain_handler(self) -> typing.Optional['CallbackHandler']:
         """
         Get Langchain handler. If Langfuse is disabled, returns None.
         """
@@ -257,8 +264,10 @@ class LangfuseClientWrapper:
         self.tags.append(self.release)
 
     def _get_tool_usage(self) -> typing.Dict:
-        """ Retrieves tool usage information from a langfuse trace.
-        Note: assumes trace marks an action with string `AgentAction` """
+        """Retrieves tool usage information from a langfuse trace.
+        Note: assumes trace marks an action with string `AgentAction`
+        """
+        from langfuse.api.resources.commons.errors.not_found_error import NotFoundError as TraceNotFoundError
 
         tool_usage = {}