MindsDB 25.9.2.0a1__py3-none-any.whl → 25.10.0rc1__py3-none-any.whl

mindsdb/api/http/initialize.py

@@ -1,7 +1,6 @@
 import os
 import mimetypes
 import threading
-import traceback
 import webbrowser
 
 from pathlib import Path
@@ -9,8 +8,7 @@ from http import HTTPStatus
 
 
 import requests
-from flask import Flask, url_for, make_response, request, send_from_directory
-from flask.json import dumps
+from flask import Flask, url_for, request, send_from_directory
 from flask_compress import Compress
 from flask_restx import Api
 from werkzeug.exceptions import HTTPException
@@ -48,7 +46,7 @@ from mindsdb.metrics.server import init_metrics
 from mindsdb.utilities import log
 from mindsdb.utilities.config import config
 from mindsdb.utilities.context import context as ctx
-from mindsdb.utilities.json_encoder import CustomJSONProvider
+from mindsdb.utilities.json_encoder import ORJSONProvider
 from mindsdb.utilities.ps import is_pid_listen_port, wait_func_is_true
 from mindsdb.utilities.sentry import sentry_sdk  # noqa: F401
 from mindsdb.utilities.otel import trace  # noqa: F401
@@ -89,14 +87,8 @@ class Swagger_Api(Api):
         return url_for(self.endpoint("specs"), _external=False)
 
 
-def custom_output_json(data, code, headers=None):
-    resp = make_response(dumps(data, cls=CustomJSONProvider), code)
-    resp.headers.extend(headers or {})
-    return resp
-
-
 def get_last_compatible_gui_version() -> Version | bool:
-    logger.debug("Getting last compatible frontend..")
+    logger.debug("Getting last compatible frontend...")
     try:
         res = requests.get(
             "https://mindsdb-web-builds.s3.amazonaws.com/compatible-config.json",
@@ -154,8 +146,8 @@ def get_last_compatible_gui_version() -> Version | bool:
             else:
                 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}")
+    except Exception:
+        logger.exception("Error in compatible-config.json structure")
         return False
 
     logger.debug(f"Last compatible frontend version: {gui_version_lv}.")
@@ -179,7 +171,6 @@ def get_current_gui_version() -> Version:
 
 
 def initialize_static():
-    logger.debug("Initializing static..")
     last_gui_version_lv = get_last_compatible_gui_version()
     current_gui_version_lv = get_current_gui_version()
     required_gui_version = config["gui"].get("version")
@@ -207,22 +198,28 @@ def initialize_static():
     return success
 
 
-def initialize_app():
+def initialize_app(is_restart: bool = False):
     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 not is_restart:
+        gui_exists = Path(static_root).joinpath("index.html").is_file()
+        logger.debug(f"Does GUI already exist.. {'YES' if gui_exists else 'NO'}")
+
+        if config["gui"]["autoupdate"] is True or (config["gui"]["open_on_start"] is True and gui_exists is False):
+            logger.debug("Initializing static...")
+            init_static_thread = threading.Thread(target=initialize_static, name="initialize_static")
+            init_static_thread.start()
+        else:
+            logger.debug(f"Skip initializing static: config['gui']={config['gui']}, gui_exists={gui_exists}")
 
-    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()
+    app, api = initialize_flask()
 
-    # Wait for static initialization.
-    if config["gui"]["open_on_start"] is True and init_static_thread is not None:
-        init_static_thread.join()
+    if not is_restart and config["gui"]["open_on_start"]:
+        if init_static_thread is not None:
+            init_static_thread.join()
+        open_gui(init_static_thread)
 
-    app, api = initialize_flask(config, init_static_thread)
     Compress(app)
 
     initialize_interfaces(app)
@@ -241,22 +238,30 @@ def initialize_app():
                 "The endpoint you are trying to access does not exist on the server.",
             )
 
-        # Normalize the path.
-        full_path = os.path.normpath(os.path.join(static_root, path))
+        try:
+            # Ensure the requested path is within the static directory
+            # https://docs.python.org/3/library/pathlib.html#pathlib.PurePath.is_relative_to
+            requested_path = (static_root / path).resolve()
+
+            if not requested_path.is_relative_to(static_root.resolve()):
+                return http_error(
+                    HTTPStatus.FORBIDDEN,
+                    "Forbidden",
+                    "You are not allowed to access the requested resource.",
+                )
+
+            if requested_path.is_file():
+                return send_from_directory(static_root, path)
+            else:
+                return send_from_directory(static_root, "index.html")
 
-        # Check for directory traversal attacks.
-        if not full_path.startswith(str(static_root)):
+        except (ValueError, OSError):
             return http_error(
-                HTTPStatus.FORBIDDEN,
-                "Forbidden",
-                "You are not allowed to access the requested resource.",
+                HTTPStatus.BAD_REQUEST,
+                "Bad Request",
+                "Invalid path requested.",
             )
 
-        if os.path.isfile(full_path):
-            return send_from_directory(static_root, path)
-        else:
-            return send_from_directory(static_root, "index.html")
-
     protected_namespaces = [
         tab_ns,
         utils_ns,
@@ -310,7 +315,6 @@ def initialize_app():
 
     @app.before_request
     def before_request():
-        logger.debug(f"HTTP {request.method}: {request.path}")
         ctx.set_default()
 
         h = request.headers.get("Authorization")
@@ -371,8 +375,8 @@ def initialize_app():
     return app
 
 
-def initialize_flask(config, init_static_thread):
-    logger.debug("Initializing flask..")
+def initialize_flask():
+    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")
@@ -393,7 +397,7 @@ def initialize_flask(config, init_static_thread):
 
     app.config["SEND_FILE_MAX_AGE_DEFAULT"] = 60
     app.config["SWAGGER_HOST"] = "http://localhost:8000/mindsdb"
-    app.json = CustomJSONProvider()
+    app.json = ORJSONProvider(app)
 
     authorizations = {"apikey": {"type": "apiKey", "in": "header", "name": "Authorization"}}
 
@@ -407,30 +411,41 @@ def initialize_flask(config, init_static_thread):
         doc="/doc/",
     )
 
-    api.representations["application/json"] = custom_output_json
+    def __output_json_orjson(data, code, headers=None):
+        from flask import current_app, make_response
 
-    port = config["api"]["http"]["port"]
-    host = config["api"]["http"]["host"]
+        dumped = current_app.json.dumps(data)
+        resp = make_response(dumped, code)
+        if headers:
+            resp.headers.extend(headers)
+        resp.mimetype = "application/json"
+        return resp
 
-    if config["gui"]["open_on_start"]:
-        if host in ("", "0.0.0.0"):
-            url = f"http://127.0.0.1:{port}/"
-        else:
-            url = f"http://{host}:{port}/"
-        logger.info(f" - GUI available at {url}")
-
-        pid = os.getpid()
-        thread = threading.Thread(
-            target=_open_webbrowser,
-            args=(url, pid, port, init_static_thread, config["paths"]["static"]),
-            daemon=True,
-            name="open_webbrowser",
-        )
-        thread.start()
+    api.representations["application/json"] = __output_json_orjson
 
     return app, api
 
 
+def open_gui(init_static_thread):
+    port = config["api"]["http"]["port"]
+    host = config["api"]["http"]["host"]
+
+    if host in ("", "0.0.0.0"):
+        url = f"http://127.0.0.1:{port}/"
+    else:
+        url = f"http://{host}:{port}/"
+    logger.info(f" - GUI available at {url}")
+
+    pid = os.getpid()
+    thread = threading.Thread(
+        target=_open_webbrowser,
+        args=(url, pid, port, init_static_thread, config["paths"]["static"]),
+        daemon=True,
+        name="open_webbrowser",
+    )
+    thread.start()
+
+
 def initialize_interfaces(app):
     app.integration_controller = integration_controller
     app.database_controller = DatabaseController()
@@ -449,7 +464,6 @@ def _open_webbrowser(url: str, pid: int, port: int, init_static_thread, static_f
         is_http_active = wait_func_is_true(func=is_pid_listen_port, timeout=15, pid=pid, port=port)
         if is_http_active:
             webbrowser.open(url)
-    except Exception as e:
-        logger.error(f"Failed to open {url} in webbrowser with exception {e}")
-        logger.error(traceback.format_exc())
+    except Exception:
+        logger.exception(f"Failed to open {url} in webbrowser with exception:")
     db.session.close()

mindsdb/api/http/namespaces/agents.py

@@ -1,6 +1,5 @@
 import os
 import json
-import traceback
 from http import HTTPStatus
 from typing import Dict, Iterable, List
 
@@ -27,9 +26,6 @@ def create_agent(project_name, name, agent):
     if name is None:
         return http_error(HTTPStatus.BAD_REQUEST, "Missing field", 'Missing "name" field for agent')
 
-    if not name.islower():
-        return http_error(HTTPStatus.BAD_REQUEST, "Wrong name", f"The name must be in lower case: {name}")
-
     model_name = agent.get("model_name")
     provider = agent.get("provider")
     skills = agent.get("skills", [])
@@ -307,10 +303,10 @@ def _completion_event_generator(agent_name: str, messages: List[Dict], project_n
 
         logger.info("Completion stream finished")
 
-    except Exception as e:
-        logger.error(f"Error in completion event generator: {e}")
-        logger.error(traceback.format_exc())
-        yield json_serialize({"error": "error in completion event generator"})
+    except Exception:
+        error_message = "Error in completion event generator"
+        logger.exception(error_message)
+        yield json_serialize({"error": error_message})
 
     finally:
         yield json_serialize({"type": "end"})
@@ -337,12 +333,12 @@ class AgentCompletionsStream(Resource):
         try:
             existing_agent = session.agents_controller.get_agent(agent_name, project_name=project_name)
             if existing_agent is None:
-                logger.error(f"Agent {agent_name} not found in project {project_name}")
+                logger.warning(f"Agent {agent_name} not found in project {project_name}")
                 return http_error(
                     HTTPStatus.NOT_FOUND, "Agent not found", f"Agent with name {agent_name} does not exist"
                 )
         except ValueError as e:
-            logger.error(f"Project {project_name} not found: {str(e)}")
+            logger.warning(f"Project {project_name} not found: {e}")
             return http_error(
                 HTTPStatus.NOT_FOUND, "Project not found", f"Project with name {project_name} does not exist"
             )
@@ -352,10 +348,9 @@ class AgentCompletionsStream(Resource):
             logger.info(f"Starting streaming response for agent {agent_name}")
             return Response(gen, mimetype="text/event-stream")
         except Exception as e:
-            logger.error(f"Error during streaming for agent {agent_name}: {str(e)}")
-            logger.error(traceback.format_exc())
+            logger.exception(f"Error during streaming for agent {agent_name}:")
             return http_error(
-                HTTPStatus.INTERNAL_SERVER_ERROR, "Streaming error", f"An error occurred during streaming: {str(e)}"
+                HTTPStatus.INTERNAL_SERVER_ERROR, "Streaming error", f"An error occurred during streaming: {e}"
             )
 
 
@@ -416,8 +411,8 @@ class AgentCompletions(Resource):
                     last_context = completion.iloc[-1]["context"]
                     if last_context:
                         context = json.loads(last_context)
-                except (json.JSONDecodeError, IndexError) as e:
-                    logger.error(f"Error decoding context: {e}")
+                except (json.JSONDecodeError, IndexError):
+                    logger.warning("Error decoding context:", exc_info=True)
                     pass  # Keeping context as an empty list in case of error
 
             response["message"]["context"] = context

mindsdb/api/http/namespaces/analysis.py

@@ -36,6 +36,7 @@ def analyze_df(df: DataFrame) -> dict:
     df.columns = cols
 
     from dataprep_ml.insights import analyze_dataset
+
     analysis = analyze_dataset(df)
     return analysis.to_dict()
 
@@ -43,7 +44,7 @@ def analyze_df(df: DataFrame) -> dict:
 @ns_conf.route("/query")
 class QueryAnalysis(Resource):
     @ns_conf.doc("post_query_to_analyze")
-    @api_endpoint_metrics('POST', '/analysis/query')
+    @api_endpoint_metrics("POST", "/analysis/query")
     def post(self):
         data = request.json
         query = data.get("query")
@@ -67,10 +68,8 @@ class QueryAnalysis(Resource):
         try:
             result = mysql_proxy.process_query(query)
         except Exception as e:
-            import traceback
-
-            logger.error(traceback.format_exc())
-            return http_error(500, "Error", str(e))
+            logger.exception("Error during query analysis:")
+            return http_error(500, "Error", f"Unexpected error duting query analysis: {e}")
 
         if result.type == SQL_RESPONSE_TYPE.ERROR:
             return http_error(500, f"Error {result.error_code}", result.error_message)
@@ -83,14 +82,12 @@ class QueryAnalysis(Resource):
             analysis = analyze_df(df)
         except ImportError:
             return {
-                'analysis': {},
-                'timestamp': time.time(),
-                'error': 'To use this feature, please install the "dataprep_ml" package.'
+                "analysis": {},
+                "timestamp": time.time(),
+                "error": 'To use this feature, please install the "dataprep_ml" package.',
             }
 
-        query_tables = [
-            table.to_string() for table in get_query_tables(ast)
-        ]
+        query_tables = [table.to_string() for table in get_query_tables(ast)]
 
         return {
             "analysis": analysis,
@@ -104,7 +101,7 @@ class QueryAnalysis(Resource):
 @ns_conf.route("/data")
 class DataAnalysis(Resource):
     @ns_conf.doc("post_data_to_analyze")
-    @api_endpoint_metrics('POST', '/analysis/data')
+    @api_endpoint_metrics("POST", "/analysis/data")
     def post(self):
         payload = request.json
         column_names = payload.get("column_names")
@@ -116,15 +113,11 @@ class DataAnalysis(Resource):
             return {"analysis": analysis, "timestamp": time.time()}
         except ImportError:
             return {
-                'analysis': {},
-                'timestamp': timestamp,
-                'error': 'To use this feature, please install the "dataprep_ml" package.'
+                "analysis": {},
+                "timestamp": timestamp,
+                "error": 'To use this feature, please install the "dataprep_ml" package.',
             }
         except Exception as e:
             # Don't want analysis exceptions to show up on UI.
             # TODO: Fix analysis so it doesn't throw exceptions at all.
-            return {
-                'analysis': {},
-                'timestamp': timestamp,
-                'error': str(e)
-            }
+            return {"analysis": {}, "timestamp": timestamp, "error": str(e)}

mindsdb/api/http/namespaces/auth.py

@@ -117,7 +117,7 @@ class Auth(Resource):
             if resp.status_code != 200:
                 logger.warning(f"Wrong response from cloud server: {resp.status_code}")
         except Exception as e:
-            logger.warning(f"Cant't send request to cloud server: {e}")
+            logger.warning(f"Cant't send request to cloud server: {e}", exc_info=True)
 
         if request.path.endswith("/auth/callback/cloud_home"):
             return redirect(f"https://{auth_server}")

mindsdb/api/http/namespaces/chatbots.py

@@ -18,9 +18,6 @@ def create_chatbot(project_name, name, chatbot):
     if name is None:
         return http_error(HTTPStatus.BAD_REQUEST, "Missing field", 'Missing "name" field for chatbot')
 
-    if not name.islower():
-        return http_error(HTTPStatus.BAD_REQUEST, "Wrong name", f"The name must be in lower case: {name}")
-
     model_name = chatbot.get("model_name", None)
     agent_name = chatbot.get("agent_name", None)
     if model_name is None and agent_name is None:
@@ -241,8 +238,6 @@ class ChatBotResource(Resource):
                         "Chatbot already exists",
                         f"Chatbot with name {name} already exists. Please choose a different one.",
                     )
-            if not name.islower():
-                return http_error(HTTPStatus.BAD_REQUEST, "Wrong name", f"The name must be in lower case: {name}")
 
         if existing_chatbot is None:
             # Create

mindsdb/api/http/namespaces/config.py

@@ -11,6 +11,7 @@ from flask import current_app as ca
 from mindsdb.api.http.namespaces.configs.config import ns_conf
 from mindsdb.api.http.utils import http_error
 from mindsdb.metrics.metrics import api_endpoint_metrics
+from mindsdb.utilities.api_status import get_api_status
 from mindsdb.utilities import log
 from mindsdb.utilities.functions import decrypt, encrypt
 from mindsdb.utilities.config import Config
@@ -32,6 +33,13 @@ class GetConfig(Resource):
             value = config.get(key)
             if value is not None:
                 resp[key] = value
+
+        api_status = get_api_status()
+        api_configs = copy.deepcopy(config["api"])
+        for api_name, api_config in api_configs.items():
+            api_config["running"] = api_status.get(api_name, False)
+        resp["api"] = api_configs
+
         return resp
 
     @ns_conf.doc("put_config")
@@ -163,9 +171,7 @@ class Integration(Resource):
             )
 
         try:
-            engine = params["type"]
-            if engine is not None:
-                del params["type"]
+            engine = params.pop("type", None)
             params.pop("publish", False)
             storage = params.pop("storage", None)
             ca.integration_controller.add(name, engine, params)
@@ -178,10 +184,10 @@ class Integration(Resource):
                 handler.handler_storage.import_files(export)
 
         except Exception as e:
-            logger.error(str(e))
+            logger.exception("An error occurred during the creation of the integration:")
             if temp_dir is not None:
                 shutil.rmtree(temp_dir)
-            return http_error(HTTPStatus.INTERNAL_SERVER_ERROR, "Error", f"Error during config update: {str(e)}")
+            return http_error(HTTPStatus.INTERNAL_SERVER_ERROR, "Error", f"Error during config update: {e}")
 
         if temp_dir is not None:
             shutil.rmtree(temp_dir)
@@ -198,8 +204,8 @@ class Integration(Resource):
         try:
             ca.integration_controller.delete(name)
         except Exception as e:
-            logger.error(str(e))
-            return http_error(HTTPStatus.INTERNAL_SERVER_ERROR, "Error", f"Error during integration delete: {str(e)}")
+            logger.exception("An error occurred while deleting the integration")
+            return http_error(HTTPStatus.INTERNAL_SERVER_ERROR, "Error", f"Error during integration delete: {e}")
         return "", 200
 
     @ns_conf.doc("modify_integration")
@@ -223,8 +229,6 @@ class Integration(Resource):
             ca.integration_controller.modify(name, params)
 
         except Exception as e:
-            logger.error(str(e))
-            return http_error(
-                HTTPStatus.INTERNAL_SERVER_ERROR, "Error", f"Error during integration modification: {str(e)}"
-            )
+            logger.exception("An error occurred while modifying the integration")
+            return http_error(HTTPStatus.INTERNAL_SERVER_ERROR, "Error", f"Error during integration modification: {e}")
         return "", 200