MindsDB 25.8.3.0__py3-none-any.whl → 25.9.1.1__py3-none-any.whl

mindsdb/utilities/config.py

@@ -5,7 +5,6 @@ import argparse
 import datetime
 from pathlib import Path
 from copy import deepcopy
-import multiprocessing as mp
 
 from appdirs import user_data_dir
 
@@ -160,7 +159,7 @@ class Config:
                     },
                 }
             },
-            "gui": {"autoupdate": True},
+            "gui": {"open_on_start": True, "autoupdate": True},
             "debug": False,
             "environment": "local",
             "integrations": {},
@@ -171,14 +170,6 @@ class Config:
                     "restart_on_failure": True,
                     "max_restart_count": 1,
                     "max_restart_interval_seconds": 60,
-                    "server": {
-                        "type": "waitress",  # MINDSDB_HTTP_SERVER_TYPE MINDSDB_DEFAULT_SERVER
-                        "config": {
-                            "threads": 16,
-                            "max_request_body_size": (1 << 30) * 10,  # 10GB
-                            "inbuf_overflow": (1 << 30) * 10,
-                        },
-                    },
                 },
                 "mysql": {
                     "host": api_host,
@@ -189,29 +180,11 @@ class Config:
                     "max_restart_count": 1,
                     "max_restart_interval_seconds": 60,
                 },
-                "mongodb": {"host": api_host, "port": "47336", "database": "mindsdb"},
                 "postgres": {"host": api_host, "port": "55432", "database": "mindsdb"},
-                "mcp": {
-                    "host": api_host,
-                    "port": "47337",
-                    "enabled": True,
-                    "restart_on_failure": True,
-                    "max_restart_count": 1,
-                    "max_restart_interval_seconds": 60,
-                },
                 "litellm": {
                     "host": "0.0.0.0",  # API server binds to all interfaces by default
                     "port": "8000",
                 },
-                "a2a": {
-                    "host": api_host,
-                    "port": 47338,
-                    "mindsdb_host": "localhost",
-                    "mindsdb_port": 47334,
-                    "agent_name": "my_agent",
-                    "project_name": "mindsdb",
-                    "enabled": False,
-                },
             },
             "cache": {"type": "local"},
             "ml_task_queue": {"type": "local"},
@@ -250,11 +223,12 @@ class Config:
         """Collect config values from env vars to self._env_config"""
         self._env_config = {
             "logging": {"handlers": {"console": {}, "file": {}}},
-            "api": {"http": {"server": {}}, "a2a": {}},
+            "api": {"http": {}},
             "auth": {},
             "paths": {},
             "permanent_storage": {},
             "ml_task_queue": {},
+            "gui": {},
         }
 
         # region storage root path
@@ -298,21 +272,6 @@ class Config:
             self._env_config["auth"]["password"] = http_password
         # endregion
 
-        # region permanent session lifetime
-        for env_name in (
-            "MINDSDB_HTTP_PERMANENT_SESSION_LIFETIME",
-            "FLASK_PERMANENT_SESSION_LIFETIME",
-        ):
-            env_value = os.environ.get(env_name)
-            if isinstance(env_value, str):
-                try:
-                    permanent_session_lifetime = int(env_value)
-                except Exception:
-                    raise ValueError(f"Warning: Can't cast env var {env_name} value to int: {env_value}")
-                self._env_config["auth"]["http_permanent_session_lifetime"] = permanent_session_lifetime
-                break
-        # endregion
-
         # region logging
         if os.environ.get("MINDSDB_LOG_LEVEL", "") != "":
             self._env_config["logging"]["handlers"]["console"]["level"] = os.environ["MINDSDB_LOG_LEVEL"]
@@ -325,35 +284,6 @@ class Config:
             self._env_config["logging"]["handlers"]["file"]["enabled"] = True
         # endregion
 
-        # region server type
-        server_type = os.environ.get("MINDSDB_HTTP_SERVER_TYPE", "").lower()
-        if server_type == "":
-            server_type = os.environ.get("MINDSDB_DEFAULT_SERVER", "").lower()
-        if server_type != "":
-            if server_type == "waitress":
-                self._env_config["api"]["http"]["server"]["type"] = "waitress"
-                self._default_config["api"]["http"]["server"]["config"] = {}
-                self._env_config["api"]["http"]["server"]["config"] = {
-                    "threads": 16,
-                    "max_request_body_size": (1 << 30) * 10,  # 10GB
-                    "inbuf_overflow": (1 << 30) * 10,
-                }
-            elif server_type == "flask":
-                self._env_config["api"]["http"]["server"]["type"] = "flask"
-                self._default_config["api"]["http"]["server"]["config"] = {}
-                self._env_config["api"]["http"]["server"]["config"] = {}
-            elif server_type == "gunicorn":
-                self._env_config["api"]["http"]["server"]["type"] = "gunicorn"
-                self._default_config["api"]["http"]["server"]["config"] = {}
-                self._env_config["api"]["http"]["server"]["config"] = {
-                    "workers": min(mp.cpu_count(), 4),
-                    "timeout": 600,
-                    "reuse_port": True,
-                    "preload_app": True,
-                    "threads": 4,
-                }
-        # endregion
-
         if os.environ.get("MINDSDB_DB_CON", "") != "":
             self._env_config["storage_db"] = os.environ["MINDSDB_DB_CON"]
 
@@ -373,31 +303,9 @@ class Config:
         if os.environ.get("MINDSDB_DATA_CATALOG_ENABLED", "").lower() in ("1", "true"):
             self._env_config["data_catalog"] = {"enabled": True}
 
-        # region vars: a2a configuration
-        a2a_config = {}
-        if os.environ.get("MINDSDB_A2A_HOST"):
-            a2a_config["host"] = os.environ.get("MINDSDB_A2A_HOST")
-        if os.environ.get("MINDSDB_A2A_PORT"):
-            a2a_config["port"] = int(os.environ.get("MINDSDB_A2A_PORT"))
-        if os.environ.get("MINDSDB_HOST"):
-            a2a_config["mindsdb_host"] = os.environ.get("MINDSDB_HOST")
-        if os.environ.get("MINDSDB_PORT"):
-            a2a_config["mindsdb_port"] = int(os.environ.get("MINDSDB_PORT"))
-        if os.environ.get("MINDSDB_AGENT_NAME"):
-            a2a_config["agent_name"] = os.environ.get("MINDSDB_AGENT_NAME")
-        if os.environ.get("MINDSDB_PROJECT_NAME"):
-            a2a_config["project_name"] = os.environ.get("MINDSDB_PROJECT_NAME")
-        if os.environ.get("MINDSDB_A2A_ENABLED") is not None:
-            a2a_config["enabled"] = os.environ.get("MINDSDB_A2A_ENABLED").lower() in (
-                "true",
-                "1",
-                "yes",
-                "y",
-            )
-
-        if a2a_config:
-            self._env_config["api"]["a2a"] = a2a_config
-        # endregion
+        if os.environ.get("MINDSDB_NO_STUDIO", "").lower() in ("1", "true"):
+            self._env_config["gui"]["open_on_start"] = False
+            self._env_config["gui"]["autoupdate"] = False
 
     def fetch_auto_config(self) -> bool:
         """Load dict readed from config.auto.json to `auto_config`.
@@ -430,10 +338,11 @@ class Config:
         """
         if self._user_config is None:
             cmd_args_config = self.cmd_args.config
-            if isinstance(cmd_args_config, str):
-                self.config_path = cmd_args_config
-            elif isinstance(os.environ.get("MINDSDB_CONFIG_PATH"), str):
+            if isinstance(os.environ.get("MINDSDB_CONFIG_PATH"), str):
                 self.config_path = os.environ["MINDSDB_CONFIG_PATH"]
+            elif isinstance(cmd_args_config, str):
+                self.config_path = cmd_args_config
+
             if self.config_path == "absent":
                 self.config_path = None
             if isinstance(self.config_path, str):
@@ -459,40 +368,13 @@ class Config:
         """Merge multiple configs to one."""
         new_config = deepcopy(self._default_config)
         _merge_configs(new_config, self._user_config)
-        _merge_configs(new_config, self._auto_config or {})
-        _merge_configs(new_config, self._env_config or {})
-
-        # Apply command-line arguments for A2A
-        a2a_config = {}
-
-        # Check for A2A command-line arguments
-        if hasattr(self.cmd_args, "a2a_host") and self.cmd_args.a2a_host is not None:
-            a2a_config["host"] = self.cmd_args.a2a_host
-
-        if hasattr(self.cmd_args, "a2a_port") and self.cmd_args.a2a_port is not None:
-            a2a_config["port"] = self.cmd_args.a2a_port
 
-        if hasattr(self.cmd_args, "mindsdb_host") and self.cmd_args.mindsdb_host is not None:
-            a2a_config["mindsdb_host"] = self.cmd_args.mindsdb_host
+        if getattr(self.cmd_args, "no_studio", None) is True:
+            new_config["gui"]["open_on_start"] = False
+            new_config["gui"]["autoupdate"] = False
 
-        if hasattr(self.cmd_args, "mindsdb_port") and self.cmd_args.mindsdb_port is not None:
-            a2a_config["mindsdb_port"] = self.cmd_args.mindsdb_port
-
-        if hasattr(self.cmd_args, "agent_name") and self.cmd_args.agent_name is not None:
-            a2a_config["agent_name"] = self.cmd_args.agent_name
-
-        if hasattr(self.cmd_args, "project_name") and self.cmd_args.project_name is not None:
-            a2a_config["project_name"] = self.cmd_args.project_name
-
-        # Merge command-line args config with highest priority
-        if a2a_config:
-            _merge_configs(new_config, {"api": {"a2a": a2a_config}})
-
-        # Ensure A2A port is never 0, which would prevent the A2A API from starting
-        a2a_config = new_config["api"].get("a2a")
-        if a2a_config is not None and isinstance(a2a_config, dict):
-            if "port" in a2a_config and (a2a_config["port"] == 0 or a2a_config["port"] is None):
-                a2a_config["port"] = 47338  # Use the default port value
+        _merge_configs(new_config, self._auto_config or {})
+        _merge_configs(new_config, self._env_config or {})
 
         # region create dirs
         for key, value in new_config["paths"].items():
@@ -550,12 +432,6 @@ class Config:
         if "log" in self._config:
             logger.warning("The 'log' config option is no longer supported. Use 'logging' instead.")
 
-        if os.environ.get("MINDSDB_DEFAULT_SERVER", "") != "":
-            logger.warning(
-                "Env variable 'MINDSDB_DEFAULT_SERVER' is going to be deprecated soon. "
-                "Use 'MINDSDB_HTTP_SERVER_TYPE' instead."
-            )
-
         file_upload_domains = self._config.get("file_upload_domains")
         if isinstance(file_upload_domains, list) and len(file_upload_domains) > 0:
             allowed_origins = self._config["url_file_upload"]["allowed_origins"]
@@ -566,14 +442,6 @@ class Config:
                 'use config["url_file_upload"]["allowed_origins"] instead.'
             )
 
-        for env_name in ("MINDSDB_HTTP_SERVER_TYPE", "MINDSDB_DEFAULT_SERVER"):
-            env_value = os.environ.get(env_name, "")
-            if env_value.lower() not in ("waitress", "flask", "gunicorn", ""):
-                logger.warning(
-                    f"The value '{env_value}' of the environment variable {env_name} is not valid. "
-                    "It must be one of the following: 'waitress', 'flask', or 'gunicorn'."
-                )
-
     @property
     def cmd_args(self):
         if self._cmd_args is None:
@@ -624,17 +492,6 @@ class Config:
             help="Project containing the agent (default: mindsdb)",
         )
 
-        # A2A specific arguments
-        parser.add_argument("--a2a-host", type=str, default=None, help="A2A server host")
-        parser.add_argument("--a2a-port", type=int, default=None, help="A2A server port")
-        parser.add_argument("--mindsdb-host", type=str, default=None, help="MindsDB server host")
-        parser.add_argument("--mindsdb-port", type=int, default=None, help="MindsDB server port")
-        parser.add_argument(
-            "--agent-name",
-            type=str,
-            default=None,
-            help="MindsDB agent name to connect to",
-        )
         parser.add_argument("--project-name", type=str, default=None, help="MindsDB project name")
         parser.add_argument("--update-gui", action="store_true", default=False, help="Update GUI and exit")
 

mindsdb/utilities/log.py

@@ -99,31 +99,6 @@ def get_handlers_config(process_name: str) -> dict:
     return handlers_config
 
 
-def get_uvicorn_logging_config(process_name: str) -> dict:
-    """Generate a logging configuration dictionary for Uvicorn using MindsDB's logging settings.
-
-    Args:
-        process_name (str): The name of the process to include in log file names and handlers.
-
-    Returns:
-        dict: A dictionary suitable for use with logging.config.dictConfig, configured for Uvicorn logging.
-    """
-    handlers_config = get_handlers_config(process_name)
-    mindsdb_log_level = get_mindsdb_log_level()
-    return {
-        "version": 1,
-        "formatters": FORMATTERS,
-        "handlers": handlers_config,
-        "loggers": {
-            "uvicorn": {
-                "handlers": list(handlers_config.keys()),
-                "level": mindsdb_log_level,
-                "propagate": False,
-            }
-        },
-    }
-
-
 def configure_logging(process_name: str = None):
     handlers_config = get_handlers_config(process_name)
     mindsdb_log_level = get_mindsdb_log_level()

mindsdb/utilities/render/sqlalchemy_render.py

@@ -47,7 +47,7 @@ def _compile_interval(element, compiler, **kw):
         if items[1].upper().endswith("S"):
             items[1] = items[1][:-1]
 
-    if compiler.dialect.driver in ["snowflake"]:
+    if compiler.dialect.driver in ["snowflake"] or compiler.dialect.name in ["postgresql"]:
         # quote all
         args = " ".join(map(str, items))
         args = f"'{args}'"
@@ -282,6 +282,12 @@ class SqlalchemyRender:
                 func = functions[t.op.lower()]
                 col = func(arg0, arg1)
             else:
+                # for unknown operators wrap arguments into parens
+                if isinstance(t.args[0], ast.BinaryOperation):
+                    arg0 = arg0.self_group()
+                if isinstance(t.args[1], ast.BinaryOperation):
+                    arg1 = arg1.self_group()
+
                 col = arg0.op(t.op)(arg1)
 
             if t.alias:

mindsdb/utilities/starters.py

@@ -18,16 +18,6 @@ def start_mysql(*args, **kwargs):
     start(*args, **kwargs)
 
 
-def start_mongo(*args, **kwargs):
-    from mindsdb.utilities.log import initialize_logging
-
-    initialize_logging("mongo")
-
-    from mindsdb.api.mongo.start import start
-
-    start(*args, **kwargs)
-
-
 def start_postgres(*args, **kwargs):
     from mindsdb.utilities.log import initialize_logging
 
@@ -68,17 +58,6 @@ def start_scheduler(*args, **kwargs):
     start(*args, **kwargs)
 
 
-def start_mcp(*args, **kwargs):
-    """Start the MCP server"""
-    from mindsdb.utilities.log import initialize_logging
-
-    initialize_logging("mcp")
-
-    from mindsdb.api.mcp.start import start
-
-    start(*args, **kwargs)
-
-
 def start_litellm(*args, **kwargs):
     """Start the LiteLLM server"""
     from mindsdb.utilities.log import initialize_logging
@@ -88,21 +67,3 @@ def start_litellm(*args, **kwargs):
     from mindsdb.api.litellm.start import start
 
     start(*args, **kwargs)
-
-
-def start_a2a(*args, **kwargs):
-    """Start the A2A server as a subprocess of the main MindsDB process"""
-    from mindsdb.utilities.log import initialize_logging
-
-    initialize_logging("a2a")
-
-    from mindsdb.api.a2a.run_a2a import main
-
-    # Extract configuration from the global config
-    from mindsdb.utilities.config import Config
-
-    config = Config()
-    a2a_config = config.get("api", {}).get("a2a", {})
-
-    # Pass configuration to the A2A main function
-    main(a2a_config, *args, **kwargs)