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

mindsdb/__about__.py

@@ -1,6 +1,6 @@
 __title__ = 'MindsDB'
 __package_name__ = 'mindsdb'
-__version__ = '25.2.4.0'
+__version__ = '25.3.2.0'
 __description__ = "MindsDB's AI SQL Server enables developers to build AI tools that need access to real-time data to perform their tasks"
 __email__ = "jorge@mindsdb.com"
 __author__ = 'MindsDB Inc'

mindsdb/__main__.py

@@ -9,10 +9,10 @@ import secrets
 import traceback
 import threading
 from enum import Enum
-from packaging import version
 from dataclasses import dataclass, field
 from typing import Callable, Optional, Tuple, List
 
+from packaging import version
 from sqlalchemy.orm.attributes import flag_modified
 
 from mindsdb.utilities import log
@@ -22,12 +22,14 @@ logger.debug("Starting MindsDB...")
 
 from mindsdb.__about__ import __version__ as mindsdb_version
 from mindsdb.utilities.config import config
+from mindsdb.utilities.exception import EntityNotExistsError
 from mindsdb.utilities.starters import (
     start_http, start_mysql, start_mongo, start_postgres, start_ml_task_queue, start_scheduler, start_tasks
 )
 from mindsdb.utilities.ps import is_pid_listen_port, get_child_pids
 from mindsdb.utilities.functions import get_versions_where_predictors_become_obsolete
 from mindsdb.interfaces.database.integrations import integration_controller
+from mindsdb.interfaces.database.projects import ProjectController
 import mindsdb.interfaces.storage.db as db
 from mindsdb.integrations.utilities.install import install_dependencies
 from mindsdb.utilities.fs import clean_process_marks, clean_unlinked_process_marks
@@ -293,6 +295,19 @@ if __name__ == '__main__':
         except Exception as e:
             logger.error(f"Error! Something went wrong during DB migrations: {e}")
 
+        logger.debug(f"Checking if default project {config.get('default_project')} exists")
+        project_controller = ProjectController()
+
+        current_default_project = project_controller.get(is_default=True)
+        if current_default_project.record.name != config.get('default_project'):
+            try:
+                new_default_project = project_controller.get(name=config.get('default_project'))
+                log.critical(f"A project with the name '{config.get('default_project')}' already exists")
+                sys.exit(1)
+            except EntityNotExistsError:
+                pass
+            project_controller.update(current_default_project.record.id, new_name=config.get('default_project'))
+
     apis = os.getenv('MINDSDB_APIS') or config.cmd_args.api
 
     if apis is None:  # If "--api" option is not specified, start the default APIs

mindsdb/api/executor/command_executor.py

@@ -1549,7 +1549,7 @@ class ExecuteCommands:
         elif isinstance(database_name, str) and len(database_name) > 0:
             db = database_name
         else:
-            db = "mindsdb"
+            db = self.session.config.get("default_project")
         table_name = target.parts[-1]
 
         new_where = BinaryOperation(

mindsdb/api/executor/datahub/datanodes/system_tables.py

@@ -8,6 +8,7 @@ from mindsdb.api.executor.datahub.classes.tables_row import (
     TablesRow,
 )
 from mindsdb.utilities import log
+from mindsdb.utilities.config import config
 
 logger = log.getLogger(__name__)
 
@@ -292,7 +293,11 @@ class ColumnsTable(Table):
         databases, tables_names = _get_scope(query)
 
         if databases is None:
-            databases = ['information_schema', 'mindsdb', 'files']
+            databases = [
+                'information_schema',
+                config.get('default_project'),
+                'files'
+            ]
 
         for db_name in databases:
             tables = {}

mindsdb/api/executor/planner/query_planner.py

@@ -25,6 +25,10 @@ from mindsdb.api.executor.planner.utils import (
 )
 from mindsdb.api.executor.planner.plan_join import PlanJoin
 from mindsdb.api.executor.planner.query_prepare import PreparedStatementPlanner
+from mindsdb.utilities.config import config
+
+
+default_project = config.get('default_project')
 
 
 class QueryPlanner:
@@ -54,12 +58,12 @@ class QueryPlanner:
                 self.integrations[integration_name] = integration
 
         # allow to select from mindsdb namespace
-        _projects.add('mindsdb')
+        _projects.add(default_project)
 
         self.default_namespace = default_namespace
 
         # legacy parameter
-        self.predictor_namespace = predictor_namespace.lower() if predictor_namespace else 'mindsdb'
+        self.predictor_namespace = predictor_namespace.lower() if predictor_namespace else default_project
 
         # map for lower names of predictors
 

mindsdb/api/executor/sql_query/steps/prepare_steps.py

@@ -10,6 +10,7 @@ from mindsdb.api.executor.planner.steps import (
 )
 
 from mindsdb.api.executor.sql_query.result_set import ResultSet, Column
+from mindsdb.utilities.config import config
 
 from .base import BaseStepCall
 
@@ -20,7 +21,7 @@ class GetPredictorColumnsCall(BaseStepCall):
 
     def call(self, step):
 
-        mindsdb_database_name = 'mindsdb'
+        mindsdb_database_name = config.get('default_project')
 
         predictor_name = step.predictor.parts[-1]
         dn = self.session.datahub.get(mindsdb_database_name)

mindsdb/api/executor/sql_query/steps/union_step.py

@@ -1,9 +1,9 @@
-import hashlib
-
 from mindsdb.api.executor.planner.steps import UnionStep
 
 from mindsdb.api.executor.sql_query.result_set import ResultSet
 from mindsdb.api.executor.exceptions import WrongArgumentError
+from mindsdb.api.executor.utilities.sql import query_df_with_type_infer_fallback
+import numpy as np
 
 from .base import BaseStepCall
 
@@ -30,27 +30,24 @@ class UnionStepCall(BaseStepCall):
         #         if type1 != type2:
         #             raise ErSqlWrongArguments(f'UNION types mismatch: {type1} != {type2}')
 
-        data = ResultSet()
-        for col in left_result.columns:
-            data.add_column(col)
-
-        records_hashes = []
-        results = []
-        for row in left_result.to_lists():
-            if step.unique:
-                checksum = hashlib.sha256(str(row).encode()).hexdigest()
-                if checksum in records_hashes:
-                    continue
-                records_hashes.append(checksum)
-            results.append(list(row))
-
-        for row in right_result.to_lists():
-            if step.unique:
-                checksum = hashlib.sha256(str(row).encode()).hexdigest()
-                if checksum in records_hashes:
-                    continue
-                records_hashes.append(checksum)
-            results.append(list(row))
-        data.add_raw_values(results)
+        table_a, names = left_result.to_df_cols()
+        table_b, _ = right_result.to_df_cols()
+
+        op = 'UNION ALL'
+        if step.unique:
+            op = 'UNION'
+        query = f"""
+            SELECT * FROM table_a
+            {op}
+            SELECT * FROM table_b
+        """
+
+        resp_df, _description = query_df_with_type_infer_fallback(query, {
+            'table_a': table_a,
+            'table_b': table_b
+        })
+        resp_df.replace({np.nan: None}, inplace=True)
+
+        data = ResultSet().from_df_cols(resp_df, col_names=names)
 
         return data

mindsdb/api/http/gui.py

@@ -5,6 +5,7 @@ from pathlib import Path
 from zipfile import ZipFile
 
 import requests
+from packaging.version import Version
 
 from mindsdb.utilities.config import Config
 from mindsdb.utilities import log
@@ -65,7 +66,7 @@ def download_gui(destignation, version):
     """
 
 
-def update_static(gui_version_lv):
+def update_static(gui_version: Version):
     """Update Scout files basing on compatible-config.json content.
     Files will be downloaded and updated if new version of GUI > current.
     Current GUI version stored in static/version.txt.
@@ -74,11 +75,11 @@ def update_static(gui_version_lv):
     static_path = Path(config["paths"]["static"])
 
     logger.info(
-        f"New version of GUI available ({gui_version_lv.vstring}). Downloading..."
+        f"New version of GUI available ({gui_version.base_version}). Downloading..."
     )
 
     temp_dir = tempfile.mkdtemp(prefix="mindsdb_gui_files_")
-    success = download_gui(temp_dir, gui_version_lv.vstring)
+    success = download_gui(temp_dir, gui_version.base_version)
     if success is False:
         shutil.rmtree(temp_dir)
         return False
@@ -90,5 +91,5 @@ def update_static(gui_version_lv):
     shutil.copytree(temp_dir, str(static_path))
     shutil.rmtree(temp_dir_for_rm)
 
-    logger.info(f"GUI version updated to {gui_version_lv.vstring}")
+    logger.info(f"GUI version updated to {gui_version.base_version}")
     return True

mindsdb/api/http/initialize.py

@@ -6,7 +6,6 @@ import traceback
 import webbrowser
 from pathlib import Path
 from http import HTTPStatus
-from distutils.version import LooseVersion
 
 import requests
 from flask import Flask, url_for, make_response, request, send_from_directory
@@ -14,6 +13,7 @@ from flask.json import dumps
 from flask_compress import Compress
 from flask_restx import Api
 from werkzeug.exceptions import HTTPException
+from packaging.version import Version, parse as parse_version
 
 from mindsdb.__about__ import __version__ as mindsdb_version
 from mindsdb.api.http.gui import update_static
@@ -72,7 +72,7 @@ def custom_output_json(data, code, headers=None):
     return resp
 
 
-def get_last_compatible_gui_version() -> LooseVersion:
+def get_last_compatible_gui_version() -> Version:
     logger.debug("Getting last compatible frontend..")
     try:
         res = requests.get('https://mindsdb-web-builds.s3.amazonaws.com/compatible-config.json', timeout=5)
@@ -95,7 +95,7 @@ def get_last_compatible_gui_version() -> LooseVersion:
         logger.error(f"Cant decode compatible-config.json: {e}")
         return False
 
-    current_mindsdb_lv = LooseVersion(mindsdb_version)
+    current_mindsdb_lv = parse_version(mindsdb_version)
 
     try:
         gui_versions = {}
@@ -103,31 +103,31 @@ def get_last_compatible_gui_version() -> LooseVersion:
         max_gui_lv = None
         for el in versions['mindsdb']:
             if el['mindsdb_version'] is None:
-                gui_lv = LooseVersion(el['gui_version'])
+                gui_lv = parse_version(el['gui_version'])
             else:
-                mindsdb_lv = LooseVersion(el['mindsdb_version'])
-                gui_lv = LooseVersion(el['gui_version'])
-                if mindsdb_lv.vstring not in gui_versions or gui_lv > gui_versions[mindsdb_lv.vstring]:
-                    gui_versions[mindsdb_lv.vstring] = gui_lv
+                mindsdb_lv = parse_version(el['mindsdb_version'])
+                gui_lv = parse_version(el['gui_version'])
+                if mindsdb_lv.base_version not in gui_versions or gui_lv > gui_versions[mindsdb_lv.base_version]:
+                    gui_versions[mindsdb_lv.base_version] = gui_lv
                 if max_mindsdb_lv is None or max_mindsdb_lv < mindsdb_lv:
                     max_mindsdb_lv = mindsdb_lv
             if max_gui_lv is None or max_gui_lv < gui_lv:
                 max_gui_lv = gui_lv
 
-        all_mindsdb_lv = [LooseVersion(x) for x in gui_versions.keys()]
+        all_mindsdb_lv = [parse_version(x) for x in gui_versions.keys()]
         all_mindsdb_lv.sort()
 
-        if current_mindsdb_lv.vstring in gui_versions:
-            gui_version_lv = gui_versions[current_mindsdb_lv.vstring]
+        if current_mindsdb_lv.base_version in gui_versions:
+            gui_version_lv = gui_versions[current_mindsdb_lv.base_version]
         elif current_mindsdb_lv > all_mindsdb_lv[-1]:
             gui_version_lv = max_gui_lv
         else:
-            lower_versions = {key: value for key, value in gui_versions.items() if LooseVersion(key) < current_mindsdb_lv}
+            lower_versions = {key: value for key, value in gui_versions.items() if parse_version(key) < current_mindsdb_lv}
             if len(lower_versions) == 0:
-                gui_version_lv = gui_versions[all_mindsdb_lv[0].vstring]
+                gui_version_lv = gui_versions[all_mindsdb_lv[0].base_version]
             else:
-                all_lower_versions = [LooseVersion(x) for x in lower_versions.keys()]
-                gui_version_lv = gui_versions[all_lower_versions[-1].vstring]
+                all_lower_versions = [parse_version(x) for x in lower_versions.keys()]
+                gui_version_lv = gui_versions[all_lower_versions[-1].base_version]
     except Exception as e:
         logger.error(f"Error in compatible-config.json structure: {e}")
         return False
@@ -136,7 +136,7 @@ def get_last_compatible_gui_version() -> LooseVersion:
     return gui_version_lv
 
 
-def get_current_gui_version() -> LooseVersion:
+def get_current_gui_version() -> Version:
     logger.debug("Getting current frontend version..")
     config = Config()
     static_path = Path(config['paths']['static'])
@@ -148,7 +148,7 @@ def get_current_gui_version() -> LooseVersion:
             current_gui_version = f.readline()
 
     current_gui_lv = (
-        None if current_gui_version is None else LooseVersion(current_gui_version)
+        None if current_gui_version is None else parse_version(current_gui_version)
     )
     logger.debug(f"Current frontend version: {current_gui_lv}.")
 
@@ -163,7 +163,7 @@ def initialize_static():
     required_gui_version = config['gui'].get('version')
 
     if required_gui_version is not None:
-        required_gui_version_lv = LooseVersion(required_gui_version)
+        required_gui_version_lv = parse_version(required_gui_version)
         success = True
         if (
             current_gui_version_lv is None
@@ -176,7 +176,7 @@ def initialize_static():
             return False
 
         # ignore versions like '23.9.2.2'
-        if current_gui_version_lv is not None and len(current_gui_version_lv.version) < 3:
+        if current_gui_version_lv is not None and len(current_gui_version_lv.release) < 3:
             if current_gui_version_lv == last_gui_version_lv:
                 return True
         logger.debug("Updating gui..")

mindsdb/api/mongo/classes/query_sql.py

@@ -1,10 +1,11 @@
 from mindsdb.api.executor.controllers import SessionController
 from mindsdb.api.executor.command_executor import ExecuteCommands
+from mindsdb.utilities.config import config
 
 
 def run_sql_command(request_env, ast_query):
     sql_session = SessionController()
-    sql_session.database = request_env.get('database', 'mindsdb')
+    sql_session.database = request_env.get('database', config.get('default_project'))
 
     command_executor = ExecuteCommands(sql_session)
     ret = command_executor.execute_command(ast_query)

mindsdb/api/mongo/responders/aggregate.py

@@ -5,8 +5,8 @@ from mindsdb_sql_parser.ast import Identifier, Insert, CreateTable
 from mindsdb.api.mongo.classes import Responder
 import mindsdb.api.mongo.functions as helpers
 from mindsdb.api.mongo.responders.find import find_to_ast
-
 from mindsdb.api.mongo.classes.query_sql import run_sql_command
+from mindsdb.utilities.config import config
 
 
 def aggregate_to_ast(query, database):
@@ -63,7 +63,7 @@ class Responce(Responder):
 
         first_step = query['pipeline'][0]
         if '$match' in first_step:
-            ast_query = aggregate_to_ast(query, request_env.get('database', 'mindsdb'))
+            ast_query = aggregate_to_ast(query, request_env.get('database', config.get('default_project')))
 
             data = run_sql_command(request_env, ast_query)
 

mindsdb/api/mongo/responders/coll_stats.py

@@ -3,6 +3,7 @@ from mindsdb_sql_parser.ast import Describe, Identifier
 from mindsdb.api.mongo.classes import Responder
 import mindsdb.api.mongo.functions as helpers
 from mindsdb.api.mongo.classes.query_sql import run_sql_command
+from mindsdb.utilities.config import config
 
 
 class Responce(Responder):
@@ -14,7 +15,7 @@ class Responce(Responder):
 
         scale = query.get('scale')
 
-        if db != 'mindsdb' or collection == 'predictors' or scale is None:
+        if db != config.get('default_project') or collection == 'predictors' or scale is None:
             # old behavior
             # NOTE real answer is huge, i removed most data from it.
             res = {
@@ -37,7 +38,7 @@ class Responce(Responder):
             }
 
             res['ns'] = f"{db}.{collection}"
-            if db == 'mindsdb' and collection == 'predictors':
+            if db == config.get('default_project') and collection == 'predictors':
                 res['count'] = len(mindsdb_env['model_controller'].get_models())
         else:
 

mindsdb/api/mongo/responders/db_stats.py

@@ -1,5 +1,6 @@
 from mindsdb.api.mongo.classes import Responder
 import mindsdb.api.mongo.functions as helpers
+from mindsdb.utilities.config import config
 
 
 class Responce(Responder):
@@ -8,7 +9,7 @@ class Responce(Responder):
     def result(self, query, request_env, mindsdb_env, session):
         db = query['$db']
         collections = 0
-        if db == 'mindsdb':
+        if db == config.get('default_project'):
             collections = 2 + len(mindsdb_env['model_controller'].get_models())
         return {
             'db': db,

mindsdb/api/mongo/responders/insert.py

@@ -16,8 +16,10 @@ from mindsdb.api.mongo.responders.find import find_to_ast
 from mindsdb.api.mongo.utilities.mongodb_parser import MongodbParser
 from mindsdb.integrations.libs.response import HandlerStatusResponse
 from mindsdb.utilities import log
+from mindsdb.utilities.config import config
 
 logger = log.getLogger(__name__)
+default_project = config.get("default_project")
 
 
 class Responce(Responder):
@@ -186,7 +188,7 @@ class Responce(Responder):
                             query["sort"] = step["args"][0]
                     # TODO implement group modifiers
                     ast_query = find_to_ast(
-                        query, request_env.get("database", "mindsdb")
+                        query, request_env.get("database", default_project)
                     )
 
                     # to string
@@ -197,7 +199,7 @@ class Responce(Responder):
                         "pipeline": mql.pipeline[0]["args"][0],
                     }
                     ast_query = aggregate_to_ast(
-                        query, request_env.get("database", "mindsdb")
+                        query, request_env.get("database", default_project)
                     )
                     query_str = ast_query.to_string()
             except Exception:

mindsdb/api/mysql/mysql_proxy/classes/fake_mysql_proxy/fake_mysql_proxy.py

@@ -1,6 +1,7 @@
 from mindsdb.api.executor.controllers import SessionController
 from mindsdb.api.mysql.mysql_proxy.libs.constants.mysql import CHARSET_NUMBERS
 from mindsdb.api.mysql.mysql_proxy.mysql_proxy import MysqlProxy
+from mindsdb.utilities.config import config
 
 
 def empty_fn():
@@ -29,7 +30,7 @@ class FakeMysqlProxy(MysqlProxy):
         self.connection_id = None
 
         self.session = SessionController()
-        self.session.database = 'mindsdb'
+        self.session.database = config.get('default_project')
 
     def is_cloud_connection(self):
         return {

mindsdb/api/mysql/mysql_proxy/mysql_proxy.py

@@ -81,7 +81,7 @@ from mindsdb.api.executor import exceptions as exec_exc
 from mindsdb.api.common.check_auth import check_auth
 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.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.wizards import make_ssl_cert
@@ -448,7 +448,6 @@ class MysqlProxy(SocketServer.BaseRequestHandler):
         connection. '0000' selected because in real mysql connection it should be lenght of package,
         and it can not be 0.
         """
-        config = Config()
         is_cloud = config.get("cloud", False)
 
         if sys.platform != "linux" or is_cloud is False:
@@ -746,7 +745,7 @@ class MysqlProxy(SocketServer.BaseRequestHandler):
                     sql = SqlStatementParser.clear_sql(sql)
                     logger.debug(f'Incoming query: {sql}')
                     profiler.set_meta(
-                        query=sql, api="mysql", environment=Config().get("environment")
+                        query=sql, api="mysql", environment=config.get("environment")
                     )
                     with profiler.Context("mysql_query_processing"):
                         response = self.process_query(sql)
@@ -877,6 +876,9 @@ class MysqlProxy(SocketServer.BaseRequestHandler):
     def set_context(self, context):
         if "db" in context:
             self.session.database = context["db"]
+        else:
+            self.session.database = config.get('default_project')
+
         if "profiling" in context:
             self.session.profiling = context["profiling"]
         if "predictor_cache" in context:
@@ -903,7 +905,6 @@ class MysqlProxy(SocketServer.BaseRequestHandler):
         Create a server and wait for incoming connections until Ctrl-C
         """
         global logger
-        config = Config()
 
         cert_path = config["api"]["mysql"].get("certificate_path")
         if cert_path is None or cert_path == "":

mindsdb/api/postgres/postgres_proxy/postgres_proxy.py

@@ -26,7 +26,7 @@ from mindsdb.api.postgres.postgres_proxy.postgres_packets.postgres_message impor
 from mindsdb.api.postgres.postgres_proxy.postgres_packets.postgres_packets import PostgresPacketReader, \
     PostgresPacketBuilder
 from mindsdb.api.postgres.postgres_proxy.utilities import strip_null_byte
-from mindsdb.utilities.config import Config
+from mindsdb.utilities.config import config
 from mindsdb.utilities.context import context as ctx
 from mindsdb.utilities import log
 from mindsdb.api.mysql.mysql_proxy.external_libs.mysql_scramble import scramble as scramble_func
@@ -92,7 +92,6 @@ class PostgresProxyHandler(socketserver.StreamRequestHandler):
                 Copied from mysql_proxy
                 TODO: Extract method into common
             """
-        config = Config()
         is_cloud = config.get('cloud', False)
 
         if sys.platform != 'linux' or is_cloud is False:
@@ -237,7 +236,7 @@ class PostgresProxyHandler(socketserver.StreamRequestHandler):
         self.server.connection_id += 1
         self.connection_id = self.server.connection_id
         self.session = SessionController()
-        self.session.database = 'mindsdb'
+        self.session.database = config.get('default_project')
 
         if hasattr(self.server, 'salt') and isinstance(self.server.salt, str):
             self.salt = self.server.salt
@@ -461,7 +460,6 @@ class PostgresProxyHandler(socketserver.StreamRequestHandler):
 
     @staticmethod
     def startProxy():
-        config = Config()
         host = config['api']['postgres']['host']
         port = int(config['api']['postgres']['port'])
         server = TcpServer((host, port), PostgresProxyHandler)

mindsdb/integrations/handlers/autosklearn_handler/autosklearn_handler.py

@@ -50,4 +50,4 @@ class AutoSklearnHandler(BaseMLEngine):
         args = self.model_storage.json_get('args')
         df[args['target']] = predictions
 
-        return df
+        return df

mindsdb/integrations/handlers/gmail_handler/connection_args.py

@@ -21,7 +21,7 @@ connection_args = OrderedDict(
     },
     code={
         'type': ARG_TYPE.STR,
-        'description': 'code after authorisation',
-        'label': 'code after authorisation',
+        'description': 'Code After Authorisation',
+        'label': 'Code After Authorisation',
     },
 )