MindsDB 25.9.1.0__py3-none-any.whl → 25.9.1.2__py3-none-any.whl

mindsdb/api/http/initialize.py

@@ -46,7 +46,7 @@ from mindsdb.interfaces.jobs.jobs_controller import JobsController
 from mindsdb.interfaces.storage import db
 from mindsdb.metrics.server import init_metrics
 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.json_encoder import CustomJSONProvider
 from mindsdb.utilities.ps import is_pid_listen_port, wait_func_is_true
@@ -95,7 +95,7 @@ def custom_output_json(data, code, headers=None):
     return resp
 
 
-def get_last_compatible_gui_version() -> Version:
+def get_last_compatible_gui_version() -> Version | bool:
     logger.debug("Getting last compatible frontend..")
     try:
         res = requests.get(
@@ -164,7 +164,6 @@ def get_last_compatible_gui_version() -> Version:
 
 def get_current_gui_version() -> Version:
     logger.debug("Getting current frontend version...")
-    config = Config()
     static_path = Path(config["paths"]["static"])
     version_txt_path = static_path.joinpath("version.txt")
 
@@ -181,7 +180,6 @@ def get_current_gui_version() -> Version:
 
 def initialize_static():
     logger.debug("Initializing static..")
-    config = Config()
     last_gui_version_lv = get_last_compatible_gui_version()
     current_gui_version_lv = get_current_gui_version()
     required_gui_version = config["gui"].get("version")
@@ -190,17 +188,18 @@ def initialize_static():
         required_gui_version_lv = parse_version(required_gui_version)
         success = True
         if current_gui_version_lv is None or required_gui_version_lv != current_gui_version_lv:
-            logger.debug("Updating gui..")
             success = update_static(required_gui_version_lv)
     else:
         if last_gui_version_lv is False:
+            logger.debug(
+                "The number of the latest version has not been determined, "
+                f"so we will continue using the current version: {current_gui_version_lv}"
+            )
             return False
 
-        # ignore versions like '23.9.2.2'
-        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..")
+        if current_gui_version_lv == last_gui_version_lv:
+            logger.debug(f"The latest version is already in use: {current_gui_version_lv}")
+            return True
         success = update_static(last_gui_version_lv)
 
     if db.session:
@@ -208,21 +207,22 @@ def initialize_static():
     return success
 
 
-def initialize_app(config, no_studio):
+def initialize_app():
     static_root = config["paths"]["static"]
     logger.debug(f"Static route: {static_root}")
     gui_exists = Path(static_root).joinpath("index.html").is_file()
     logger.debug(f"Does GUI already exist.. {'YES' if gui_exists else 'NO'}")
     init_static_thread = None
-    if no_studio is False and (config["gui"]["autoupdate"] is True or gui_exists is False):
+
+    if config["gui"]["autoupdate"] is True or (config["gui"]["open_on_start"] is True and gui_exists is False):
         init_static_thread = threading.Thread(target=initialize_static, name="initialize_static")
         init_static_thread.start()
 
     # Wait for static initialization.
-    if not no_studio and init_static_thread is not None:
+    if config["gui"]["open_on_start"] is True and init_static_thread is not None:
         init_static_thread.join()
 
-    app, api = initialize_flask(config, init_static_thread, no_studio)
+    app, api = initialize_flask(config, init_static_thread)
     Compress(app)
 
     initialize_interfaces(app)
@@ -312,7 +312,6 @@ def initialize_app(config, no_studio):
     def before_request():
         logger.debug(f"HTTP {request.method}: {request.path}")
         ctx.set_default()
-        config = Config()
 
         h = request.headers.get("Authorization")
         if not h or not h.startswith("Bearer "):
@@ -372,21 +371,18 @@ def initialize_app(config, no_studio):
     return app
 
 
-def initialize_flask(config, init_static_thread, no_studio):
+def initialize_flask(config, init_static_thread):
     logger.debug("Initializing flask..")
     # region required for windows https://github.com/mindsdb/mindsdb/issues/2526
     mimetypes.add_type("text/css", ".css")
     mimetypes.add_type("text/javascript", ".js")
     # endregion
 
-    kwargs = {}
-    if no_studio is not True:
-        static_path = os.path.join(config["paths"]["static"], "static/")
-        if os.path.isabs(static_path) is False:
-            static_path = os.path.join(os.getcwd(), static_path)
-        kwargs["static_url_path"] = "/static"
-        kwargs["static_folder"] = static_path
-        logger.debug(f"Static path: {static_path}")
+    static_path = os.path.join(config["paths"]["static"], "static/")
+    if os.path.isabs(static_path) is False:
+        static_path = os.path.join(os.getcwd(), static_path)
+    kwargs = {"static_url_path": "/static", "static_folder": static_path}
+    logger.debug(f"Static path: {static_path}")
 
     app = Flask(__name__, **kwargs)
     init_metrics(app)
@@ -416,8 +412,7 @@ def initialize_flask(config, init_static_thread, no_studio):
     port = config["api"]["http"]["port"]
     host = config["api"]["http"]["host"]
 
-    # NOTE rewrite it, that hotfix to see GUI link
-    if not no_studio:
+    if config["gui"]["open_on_start"]:
         if host in ("", "0.0.0.0"):
             url = f"http://127.0.0.1:{port}/"
         else:
@@ -441,8 +436,6 @@ def initialize_interfaces(app):
     app.database_controller = DatabaseController()
     app.file_controller = FileController()
     app.jobs_controller = JobsController()
-    config = Config()
-    app.config_obj = config
 
 
 def _open_webbrowser(url: str, pid: int, port: int, init_static_thread, static_folder):

mindsdb/api/http/namespaces/file.py

@@ -3,6 +3,7 @@ import shutil
 import tarfile
 import tempfile
 import zipfile
+from pathlib import Path
 from urllib.parse import urlparse
 
 import multipart
@@ -60,7 +61,10 @@ class File(Resource):
 
         def on_file(file):
             nonlocal file_object
-            data["file"] = file.file_name.decode()
+            file_name = file.file_name.decode()
+            data["file"] = file_name
+            if Path(file_name).name != file_name:
+                raise ValueError(f"Wrong file name: {file_name}")
             file_object = file.file_object
 
         temp_dir_path = tempfile.mkdtemp(prefix="mindsdb_file_")
@@ -72,8 +76,9 @@ class File(Resource):
                 on_file=on_file,
                 config={
                     "UPLOAD_DIR": temp_dir_path.encode(),  # bytes required
-                    "UPLOAD_KEEP_FILENAME": True,
+                    "UPLOAD_KEEP_FILENAME": False,
                     "UPLOAD_KEEP_EXTENSIONS": True,
+                    "UPLOAD_DELETE_TMP": False,
                     "MAX_MEMORY_FILE_SIZE": 0,
                 },
             )
@@ -93,6 +98,7 @@ class File(Resource):
                     except (AttributeError, ValueError, OSError):
                         logger.debug("Failed to flush file_object before closing.", exc_info=True)
                     file_object.close()
+                Path(file_object.name).rename(Path(file_object.name).parent / data["file"])
                 file_object = None
         else:
             data = request.json
@@ -101,7 +107,7 @@ class File(Resource):
             return http_error(
                 400,
                 "File already exists",
-                f"File with name '{data['file']}' already exists",
+                f"File with name '{mindsdb_file_name}' already exists",
             )
 
         if data.get("source_type") == "url":

mindsdb/api/http/namespaces/handlers.py

@@ -19,96 +19,94 @@ from mindsdb.api.http.utils import http_error
 from mindsdb.api.http.namespaces.configs.handlers import ns_conf
 from mindsdb.api.executor.controllers.session_controller import SessionController
 from mindsdb.api.executor.command_executor import ExecuteCommands
-from mindsdb.utilities.config import Config
 
 
-@ns_conf.route('/')
+@ns_conf.route("/")
 class HandlersList(Resource):
-    @ns_conf.doc('handlers_list')
-    @api_endpoint_metrics('GET', '/handlers')
+    @ns_conf.doc("handlers_list")
+    @api_endpoint_metrics("GET", "/handlers")
     def get(self):
-        '''List all db handlers'''
+        """List all db handlers"""
 
-        if request.args.get('lazy') == '1':
+        if request.args.get("lazy") == "1":
             handlers = ca.integration_controller.get_handlers_metadata()
         else:
             handlers = ca.integration_controller.get_handlers_import_status()
         result = []
         for handler_type, handler_meta in handlers.items():
             # remove non-integration handlers
-            if handler_type not in ['utilities', 'dummy_data']:
-                row = {'name': handler_type}
+            if handler_type not in ["utilities", "dummy_data"]:
+                row = {"name": handler_type}
                 row.update(handler_meta)
-                del row['path']
+                del row["path"]
                 result.append(row)
         return result
 
 
-@ns_conf.route('/<handler_name>/icon')
+@ns_conf.route("/<handler_name>/icon")
 class HandlerIcon(Resource):
-    @ns_conf.param('handler_name', 'Handler name')
-    @api_endpoint_metrics('GET', '/handlers/handler/icon')
+    @ns_conf.param("handler_name", "Handler name")
+    @api_endpoint_metrics("GET", "/handlers/handler/icon")
     def get(self, handler_name):
         try:
             handler_meta = ca.integration_controller.get_handlers_metadata().get(handler_name)
             if handler_meta is None:
-                return http_error(HTTPStatus.NOT_FOUND, 'Icon not found', f'Icon for {handler_name} not found')
-            icon_name = handler_meta['icon']['name']
-            handler_folder = handler_meta['import']['folder']
-            mindsdb_path = Path(importlib.util.find_spec('mindsdb').origin).parent
-            icon_path = mindsdb_path.joinpath('integrations/handlers').joinpath(handler_folder).joinpath(icon_name)
+                return http_error(HTTPStatus.NOT_FOUND, "Icon not found", f"Icon for {handler_name} not found")
+            icon_name = handler_meta["icon"]["name"]
+            handler_folder = handler_meta["import"]["folder"]
+            mindsdb_path = Path(importlib.util.find_spec("mindsdb").origin).parent
+            icon_path = mindsdb_path.joinpath("integrations/handlers").joinpath(handler_folder).joinpath(icon_name)
             if icon_path.is_absolute() is False:
                 icon_path = Path(os.getcwd()).joinpath(icon_path)
         except Exception:
-            return http_error(HTTPStatus.NOT_FOUND, 'Icon not found', f'Icon for {handler_name} not found')
+            return http_error(HTTPStatus.NOT_FOUND, "Icon not found", f"Icon for {handler_name} not found")
         else:
             return send_file(icon_path)
 
 
-@ns_conf.route('/<handler_name>')
+@ns_conf.route("/<handler_name>")
 class HandlerInfo(Resource):
-    @ns_conf.param('handler_name', 'Handler name')
-    @api_endpoint_metrics('GET', '/handlers/handler')
+    @ns_conf.param("handler_name", "Handler name")
+    @api_endpoint_metrics("GET", "/handlers/handler")
     def get(self, handler_name):
-
         handler_meta = ca.integration_controller.get_handler_meta(handler_name)
-        row = {'name': handler_name}
+        row = {"name": handler_name}
         row.update(handler_meta)
-        del row['path']
-        del row['icon']
+        del row["path"]
+        del row["icon"]
         return row
 
 
-@ns_conf.route('/<handler_name>/install')
+@ns_conf.route("/<handler_name>/install")
 class InstallDependencies(Resource):
-    @ns_conf.param('handler_name', 'Handler name')
-    @api_endpoint_metrics('POST', '/handlers/handler/install')
+    @ns_conf.param("handler_name", "Handler name")
+    @api_endpoint_metrics("POST", "/handlers/handler/install")
     def post(self, handler_name):
         handler_meta = ca.integration_controller.get_handler_meta(handler_name)
 
         if handler_meta is None:
-            return f'Unknown handler: {handler_name}', 400
+            return f"Unknown handler: {handler_name}", 400
 
-        if handler_meta.get('import', {}).get('success', False) is True:
-            return 'Installed', 200
+        if handler_meta.get("import", {}).get("success", False) is True:
+            return "Installed", 200
 
-        dependencies = handler_meta['import']['dependencies']
+        dependencies = handler_meta["import"]["dependencies"]
         if len(dependencies) == 0:
-            return 'Installed', 200
+            return "Installed", 200
 
         result = install_dependencies(dependencies)
 
         # reload it if any result, so we can get new error message
         ca.integration_controller.reload_handler_module(handler_name)
-        if result.get('success') is True:
+        if result.get("success") is True:
             # If warm processes are available in the cache, remove them.
             # This will force a new process to be created with the installed dependencies.
             process_cache.remove_processes_for_handler(handler_name)
-            return '', 200
+            return "", 200
         return http_error(
             500,
-            f'Failed to install dependencies for {handler_meta.get("title", handler_name)}',
-            result.get('error_message', 'unknown error')
+            f"Failed to install dependencies for {handler_meta.get('title', handler_name)}",
+            result.get("error_message", "unknown error"),
         )
 
 
@@ -122,24 +120,24 @@ def prepare_formdata():
         params[name] = value
 
     def on_file(file):
-        params[file.field_name.decode()] = file.file_object
-        file_names.append(file.field_name.decode())
+        file_name = file.field_name.decode()
+        if file_name not in ("code", "modules"):
+            raise ValueError(f"Wrong field name: {file_name}")
+        params[file_name] = file.file_object
+        file_names.append(file_name)
 
-    temp_dir_path = temp_dir_path = tempfile.mkdtemp(
-        prefix='mindsdb_byom_file_',
-        dir=Config().paths['tmp']
-    )
+    temp_dir_path = tempfile.mkdtemp(prefix="mindsdb_file_")
 
     parser = multipart.create_form_parser(
         headers=request.headers,
         on_field=on_field,
         on_file=on_file,
         config={
-            'UPLOAD_DIR': temp_dir_path.encode(),  # bytes required
-            'UPLOAD_KEEP_FILENAME': True,
-            'UPLOAD_KEEP_EXTENSIONS': True,
-            'MAX_MEMORY_FILE_SIZE': 0
-        }
+            "UPLOAD_DIR": temp_dir_path.encode(),  # bytes required
+            "UPLOAD_KEEP_FILENAME": True,
+            "UPLOAD_KEEP_EXTENSIONS": True,
+            "MAX_MEMORY_FILE_SIZE": float("inf"),
+        },
     )
 
     while True:
@@ -151,32 +149,33 @@ def prepare_formdata():
     parser.close()
 
     for file_name in file_names:
+        file_path = os.path.join(temp_dir_path, file_name)
+        with open(file_path, "wb") as f:
+            params[file_name].seek(0)
+            f.write(params[file_name].read())
         params[file_name].close()
+        params[file_name] = file_path
 
     return params
 
 
-@ns_conf.route('/byom/<name>')
-@ns_conf.param('name', "Name of the model")
+@ns_conf.route("/byom/<name>")
+@ns_conf.param("name", "Name of the model")
 class BYOMUpload(Resource):
-    @ns_conf.doc('post_file')
-    @api_endpoint_metrics('POST', '/handlers/byom/handler')
+    @ns_conf.doc("post_file")
+    @api_endpoint_metrics("POST", "/handlers/byom/handler")
     def post(self, name):
         params = prepare_formdata()
 
-        code_file_path = params['code'].name.decode()
+        code_file_path = params["code"]
         try:
-            module_file_path = params['modules'].name.decode()
+            module_file_path = params["modules"]
         except AttributeError:
-            module_file_path = Path(code_file_path).parent / 'requirements.txt'
+            module_file_path = Path(code_file_path).parent / "requirements.txt"
             module_file_path.touch()
             module_file_path = str(module_file_path)
 
-        connection_args = {
-            'code': code_file_path,
-            'modules': module_file_path,
-            'type': params.get('type')
-        }
+        connection_args = {"code": code_file_path, "modules": module_file_path, "type": params.get("type")}
 
         session = SessionController()
 
@@ -185,48 +184,39 @@ class BYOMUpload(Resource):
 
         engine_storage = HandlerStorage(base_ml_handler.integration_id)
 
-        engine_versions = [
-            int(x) for x in engine_storage.get_connection_args()['versions'].keys()
-        ]
+        engine_versions = [int(x) for x in engine_storage.get_connection_args()["versions"].keys()]
 
-        return {
-            'last_engine_version': max(engine_versions),
-            'engine_versions': engine_versions
-        }
+        return {"last_engine_version": max(engine_versions), "engine_versions": engine_versions}
 
-    @ns_conf.doc('put_file')
-    @api_endpoint_metrics('PUT', '/handlers/byom/handler')
+    @ns_conf.doc("put_file")
+    @api_endpoint_metrics("PUT", "/handlers/byom/handler")
     def put(self, name):
-        ''' upload new model
-            params in FormData:
-                - code
-                - modules
-        '''
+        """upload new model
+        params in FormData:
+            - code
+            - modules
+        """
 
         params = prepare_formdata()
 
-        code_file_path = params['code'].name.decode()
+        code_file_path = params["code"]
         try:
-            module_file_path = params['modules'].name.decode()
+            module_file_path = params["modules"]
         except KeyError:
-            module_file_path = Path(code_file_path).parent / 'requirements.txt'
+            module_file_path = Path(code_file_path).parent / "requirements.txt"
             module_file_path.touch()
             module_file_path = str(module_file_path)
 
         connection_args = {
-            'code': code_file_path,
-            'modules': module_file_path,
-            'mode': params.get('mode'),
-            'type': params.get('type')
+            "code": code_file_path,
+            "modules": module_file_path,
+            "mode": params.get("mode"),
+            "type": params.get("type"),
         }
 
-        ast_query = CreateMLEngine(
-            name=Identifier(name),
-            handler='byom',
-            params=connection_args
-        )
+        ast_query = CreateMLEngine(name=Identifier(name), handler="byom", params=connection_args)
         sql_session = SessionController()
         command_executor = ExecuteCommands(sql_session)
         command_executor.execute_command(ast_query)
 
-        return '', 200
+        return "", 200

mindsdb/api/http/start.py

@@ -26,15 +26,16 @@ gc.enable()
 logger = log.getLogger(__name__)
 
 
-def start(verbose, no_studio, app: Flask = None):
+def start(verbose, app: Flask = None):
     db.init()
     init_lexer_parsers()
 
     if app is None:
-        app = initialize_app(config, no_studio)
+        app = initialize_app()
 
     port = config["api"]["http"]["port"]
     host = config["api"]["http"]["host"]
+
     process_cache.init()
 
     routes = []

mindsdb/integrations/handlers/autogluon_handler/requirements.txt

@@ -1,2 +1,2 @@
 autogluon
-type_infer==0.0.23
+type_infer==0.0.25

mindsdb/integrations/handlers/autosklearn_handler/requirements.txt

@@ -1,2 +1,2 @@
 auto-sklearn
-type_infer==0.0.23
+type_infer==0.0.25

mindsdb/integrations/handlers/flaml_handler/requirements.txt

@@ -1,2 +1,2 @@
 flaml<=1.2.3
-type_infer==0.0.23
+type_infer==0.0.25

mindsdb/integrations/handlers/lightfm_handler/requirements.txt

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

mindsdb/integrations/handlers/lightwood_handler/requirements.txt

@@ -1,4 +1,4 @@
-lightwood>=25.7.5.1
-lightwood[extra]>=25.7.5.1
-lightwood[xai]>=25.7.5.1
-type_infer==0.0.23
+lightwood>=25.9.1.0
+lightwood[extra]>=25.9.1.0
+lightwood[xai]>=25.9.1.0
+type_infer==0.0.25

mindsdb/integrations/handlers/tpot_handler/requirements.txt

@@ -1,2 +1,2 @@
 tpot<=0.11.7
-type_infer==0.0.23
+type_infer==0.0.25

mindsdb/integrations/libs/llm/config.py

@@ -113,3 +113,18 @@ class WriterConfig(BaseLLMConfig):
     writer_api_key: Optional[str] = Field(default=None)
     writer_org_id: Optional[str] = Field(default=None)
     base_url: Optional[str] = Field(default=None)
+
+
+# https://api.python.langchain.com/en/latest/llms/langchain_aws.llms.bedrock.BedrockLLM.html#langchain_aws.llms.bedrock.BedrockLLM
+class BedrockConfig(BaseLLMConfig):
+    model_id: str
+    aws_access_key_id: Optional[str] = Field(default=None)
+    aws_secret_access_key: Optional[str] = Field(default=None)
+    aws_session_token: Optional[str] = Field(default=None)
+    region_name: Optional[str] = Field(default=None)
+    credentials_profile_name: Optional[str] = Field(default=None)
+    endpoint_url: Optional[str] = Field(default=None)
+    stop: Optional[List[str]] = Field(default=None)
+    temperature: Optional[float] = Field(default=0.7)
+    max_tokens: Optional[int] = Field(default=None)
+    model_kwargs: Optional[Dict[str, Any]] = Field(default=None)

mindsdb/integrations/libs/llm/utils.py

@@ -16,6 +16,7 @@ from mindsdb.integrations.libs.llm.config import (
     NvidiaNIMConfig,
     MindsdbConfig,
     WriterConfig,
+    BedrockConfig,
 )
 from mindsdb.utilities.config import config
 from langchain_text_splitters import Language, RecursiveCharacterTextSplitter
@@ -222,6 +223,20 @@ def get_llm_config(provider: str, args: Dict) -> BaseLLMConfig:
             writer_org_id=args.get("writer_org_id", None),
             base_url=args.get("base_url", None),
         )
+    if provider == "bedrock":
+        return BedrockConfig(
+            model_id=args.get("model_name"),
+            temperature=temperature,
+            max_tokens=args.get("max_tokens", None),
+            stop=args.get("stop", None),
+            base_url=args.get("endpoint_url", None),
+            aws_access_key_id=args.get("aws_access_key_id", None),
+            aws_secret_access_key=args.get("aws_secret_access_key", None),
+            aws_session_token=args.get("aws_session_token", None),
+            region_name=args.get("aws_region_name", None),
+            credentials_profile_name=args.get("credentials_profile_name", None),
+            model_kwargs=args.get("model_kwargs", None),
+        )
 
     raise ValueError(f"Provider {provider} is not supported.")
 

mindsdb/interfaces/agents/langchain_agent.py

@@ -40,6 +40,7 @@ from .mindsdb_chat_model import ChatMindsdb
 from .callback_handlers import LogCallbackHandler, ContextCaptureCallback
 from .langfuse_callback_handler import LangfuseCallbackHandler, get_skills
 from .safe_output_parser import SafeOutputParser
+from .providers import get_bedrock_chat_model
 
 from mindsdb.interfaces.agents.constants import (
     OPEN_AI_CHAT_MODELS,
@@ -176,6 +177,9 @@ def create_chat_model(args: Dict):
         return ChatGoogleGenerativeAI(**model_kwargs)
     if args["provider"] == "writer":
         return ChatWriter(**model_kwargs)
+    if args["provider"] == "bedrock":
+        ChatBedrock = get_bedrock_chat_model()
+        return ChatBedrock(**model_kwargs)
     if args["provider"] == "mindsdb":
         return ChatMindsdb(**model_kwargs)
     raise ValueError(f"Unknown provider: {args['provider']}")

mindsdb/interfaces/agents/providers.py

@@ -0,0 +1,20 @@
+import importlib.util
+
+
+def get_bedrock_chat_model():
+    try:
+        from langchain_aws.chat_models import ChatBedrock
+    except ModuleNotFoundError:
+        raise RuntimeError("bedrock connector is not installed. Please install it with `pip install langchain-aws`")
+
+    if not importlib.util.find_spec("transformers"):
+        raise RuntimeError(
+            "`transformers` module is required for bedrock to count tokens. Please install it with `pip install transformers`"
+        )
+
+    class ChatBedrockPatched(ChatBedrock):
+        def _prepare_input_and_invoke(self, *args, **kwargs):
+            kwargs.pop("stop_sequences", None)
+            return super()._prepare_input_and_invoke(*args, **kwargs)
+
+    return ChatBedrockPatched