MindsDB 25.2.4.0__py3-none-any.whl → 25.3.1.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.1.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

@@ -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/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',
     },
 )

mindsdb/integrations/handlers/gmail_handler/gmail_handler.py

@@ -1,7 +1,4 @@
 import json
-from shutil import copyfile
-
-import requests
 
 from mindsdb.integrations.libs.response import (
     HandlerStatusResponse as StatusResponse,
@@ -15,31 +12,28 @@ from mindsdb.utilities import log
 from mindsdb_sql_parser import parse_sql
 from mindsdb.utilities.config import Config
 
-import os
 import time
 from typing import List
 import pandas as pd
 
-from google.auth.transport.requests import Request
-from google.oauth2.credentials import Credentials
-from google_auth_oauthlib.flow import Flow
 from googleapiclient.discovery import build
 from googleapiclient.errors import HttpError
 from email.message import EmailMessage
 
 from base64 import urlsafe_b64encode, urlsafe_b64decode
 
-from .utils import AuthException, google_auth_flow, save_creds_to_file
+from mindsdb.integrations.utilities.handlers.auth_utilities import GoogleUserOAuth2Manager
+from mindsdb.integrations.utilities.handlers.auth_utilities.exceptions import AuthException
 
-DEFAULT_SCOPES = ['https://www.googleapis.com/auth/gmail.compose',
-                  'https://www.googleapis.com/auth/gmail.readonly',
-                  'https://www.googleapis.com/auth/gmail.modify']
+DEFAULT_SCOPES = [
+    'https://www.googleapis.com/auth/gmail.compose',
+    'https://www.googleapis.com/auth/gmail.readonly',
+    'https://www.googleapis.com/auth/gmail.modify'
+]
 
 logger = log.getLogger(__name__)
 
 
-
-
 class EmailsTable(APITable):
     """Implementation for the emails table for Gmail"""
 
@@ -283,6 +277,14 @@ class GmailHandler(APIHandler):
         super().__init__(name)
         self.connection_args = kwargs.get('connection_data', {})
 
+        self.token_file = None
+        self.max_page_size = 500
+        self.max_batch_size = 100
+        self.service = None
+        self.is_connected = False
+
+        self.handler_storage = kwargs['handler_storage']
+
         self.credentials_url = self.connection_args.get('credentials_url', None)
         self.credentials_file = self.connection_args.get('credentials_file', None)
         if self.connection_args.get('credentials'):
@@ -298,63 +300,11 @@ class GmailHandler(APIHandler):
                 self.credentials_url = secret_url
 
         self.scopes = self.connection_args.get('scopes', DEFAULT_SCOPES)
-        self.token_file = None
-        self.max_page_size = 500
-        self.max_batch_size = 100
-        self.service = None
-        self.is_connected = False
-
-        self.handler_storage = kwargs['handler_storage']
 
         emails = EmailsTable(self)
         self.emails = emails
         self._register_table('emails', emails)
 
-    def _download_secret_file(self, secret_file):
-        # Giving more priority to the S3 file
-        if self.credentials_url:
-            response = requests.get(self.credentials_url)
-            if response.status_code == 200:
-                with open(secret_file, 'w') as creds:
-                    creds.write(response.text)
-                return True
-            else:
-                logger.error("Failed to get credentials from S3", response.status_code)
-
-        if self.credentials_file and os.path.isfile(self.credentials_file):
-            copyfile(self.credentials_file, secret_file)
-            return True
-        return False
-
-    def create_connection(self):
-        creds = None
-
-        # Get the current dir, we'll check for Token & Creds files in this dir
-        curr_dir = self.handler_storage.folder_get('config')
-
-        creds_file = os.path.join(curr_dir, 'creds.json')
-        secret_file = os.path.join(curr_dir, 'secret.json')
-
-        if os.path.isfile(creds_file):
-            creds = Credentials.from_authorized_user_file(creds_file, self.scopes)
-
-        if not creds or not creds.valid:
-            if creds and creds.expired and creds.refresh_token:
-                creds.refresh(Request())
-
-            if self._download_secret_file(secret_file):
-                # save to storage
-                self.handler_storage.folder_sync('config')
-            else:
-                raise ValueError('No valid Gmail Credentials filepath or S3 url found.')
-
-            creds = google_auth_flow(secret_file, self.scopes, self.connection_args.get('code'))
-
-            save_creds_to_file(creds, creds_file)
-            self.handler_storage.folder_sync('config')
-
-        return build('gmail', 'v1', credentials=creds)
-
     def connect(self):
         """Authenticate with the Gmail API using the credentials file.
 
@@ -366,7 +316,10 @@ class GmailHandler(APIHandler):
         if self.is_connected and self.service is not None:
             return self.service
 
-        self.service = self.create_connection()
+        google_oauth2_manager = GoogleUserOAuth2Manager(self.handler_storage, self.scopes, self.credentials_file, self.credentials_url, self.connection_args.get('code'))
+        creds = google_oauth2_manager.get_oauth2_credentials()
+
+        self.service = build('gmail', 'v1', credentials=creds)
 
         self.is_connected = True
         return self.service

mindsdb/integrations/handlers/gmail_handler/requirements.txt

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

mindsdb/integrations/handlers/google_calendar_handler/connection_args.py

@@ -4,9 +4,24 @@ from mindsdb.integrations.libs.const import HANDLER_CONNECTION_ARG_TYPE as ARG_T
 
 
 connection_args = OrderedDict(
+    credentials_url={
+        'type': ARG_TYPE.STR,
+        'description': 'URL to Service Account Keys',
+        'label': 'URL to Service Account Keys',
+    },
+    credentials_file={
+        'type': ARG_TYPE.STR,
+        'description': 'Location of Service Account Keys',
+        'label': 'Path to Service Account Keys',
+    },
     credentials={
         'type': ARG_TYPE.PATH,
         'description': 'Service Account Keys',
         'label': 'Upload Service Account Keys',
     },
+    code={
+        'type': ARG_TYPE.STR,
+        'description': 'Code After Authorisation',
+        'label': 'Code After Authorisation',
+    },
 )

mindsdb/integrations/handlers/google_calendar_handler/google_calendar_handler.py

@@ -1,8 +1,4 @@
-import os
-
 import pandas as pd
-from google.auth.transport.requests import Request
-from google.oauth2.credentials import Credentials
 from googleapiclient.discovery import build
 
 from mindsdb.api.executor.data_types.response_type import RESPONSE_TYPE
@@ -11,13 +7,21 @@ from mindsdb.integrations.libs.response import (
     HandlerStatusResponse as StatusResponse,
     HandlerResponse as Response,
 )
+from mindsdb.utilities.config import Config
 from mindsdb.utilities import log
-logger = log.getLogger(__name__)
-
-from mindsdb.integrations.handlers.gmail_handler.utils import AuthException, google_auth_flow, save_creds_to_file
+from mindsdb.integrations.utilities.handlers.auth_utilities import GoogleUserOAuth2Manager
+from mindsdb.integrations.utilities.handlers.auth_utilities.exceptions import AuthException
 
 from .google_calendar_tables import GoogleCalendarEventsTable
 
+DEFAULT_SCOPES = [
+    'https://www.googleapis.com/auth/calendar',
+    'https://www.googleapis.com/auth/calendar.events',
+    'https://www.googleapis.com/auth/calendar.readonly'
+]
+
+logger = log.getLogger(__name__)
+
 
 class GoogleCalendarHandler(APIHandler):
     """
@@ -35,20 +39,29 @@ class GoogleCalendarHandler(APIHandler):
             events (GoogleCalendarEventsTable): The `GoogleCalendarEventsTable` object for interacting with the events table.
         """
         super().__init__(name)
+        self.connection_data = kwargs.get('connection_data', {})
 
-        self.token = None
         self.service = None
-        self.connection_data = kwargs.get('connection_data', {})
-        self.credentials_file = self.connection_data['credentials']
-        self.scopes = [
-            'https://www.googleapis.com/auth/calendar',
-            'https://www.googleapis.com/auth/calendar.events',
-            'https://www.googleapis.com/auth/calendar.readonly'
-        ]
         self.is_connected = False
 
         self.handler_storage = kwargs['handler_storage']
 
+        self.credentials_url = self.connection_data.get('credentials_url', None)
+        self.credentials_file = self.connection_data.get('credentials_file', None)
+        if self.connection_data.get('credentials'):
+            self.credentials_file = self.connection_data.pop('credentials')
+        if not self.credentials_file and not self.credentials_url:
+            # try to get from config
+            gcalendar_config = Config().get('handlers', {}).get('youtube', {})
+            secret_file = gcalendar_config.get('credentials_file')
+            secret_url = gcalendar_config.get('credentials_url')
+            if secret_file:
+                self.credentials_file = secret_file
+            elif secret_url:
+                self.credentials_url = secret_url
+
+        self.scopes = self.connection_data.get('scopes', DEFAULT_SCOPES)
+
         events = GoogleCalendarEventsTable(self)
         self.events = events
         self._register_table('events', events)
@@ -64,32 +77,8 @@ class GoogleCalendarHandler(APIHandler):
         if self.is_connected is True:
             return self.service
 
-        secret_file = self.credentials_file
-
-        curr_dir = self.handler_storage.folder_get('config')
-
-        creds_file = None
-        try:
-            creds_file = os.path.join(curr_dir, 'secret.json')
-        except Exception:
-            pass
-
-        creds = None
-        if os.path.isfile(creds_file):
-            creds = Credentials.from_authorized_user_file(creds_file, self.scopes)
-
-        if not creds or not creds.valid:
-            if creds and creds.expired and creds.refresh_token:
-                creds.refresh(Request())
-
-                save_creds_to_file(creds, creds_file)
-                self.handler_storage.folder_sync('config')
-
-            else:
-                creds = google_auth_flow(secret_file, self.scopes, self.connection_data.get('code'))
-
-                save_creds_to_file(creds, creds_file)
-                self.handler_storage.folder_sync('config')
+        google_oauth2_manager = GoogleUserOAuth2Manager(self.handler_storage, self.scopes, self.credentials_file, self.credentials_url, self.connection_data.get('code'))
+        creds = google_oauth2_manager.get_oauth2_credentials()
 
         self.service = build('calendar', 'v3', credentials=creds)
         return self.service
@@ -106,6 +95,7 @@ class GoogleCalendarHandler(APIHandler):
         try:
             self.connect()
             response.success = True
+            response.copy_storage = True
 
         except AuthException as error:
             response.error_message = str(error)

mindsdb/integrations/handlers/google_calendar_handler/requirements.txt

@@ -1,3 +1 @@
 google-api-python-client
-google-auth-httplib2
--r mindsdb/integrations/handlers/gmail_handler/requirements.txt