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

mindsdb/api/a2a/run_a2a.py

@@ -1,86 +0,0 @@
-#!/usr/bin/env python
-import os
-import sys
-import logging
-from dotenv import load_dotenv
-from typing import Dict, Any, Optional
-
-# Configure logging
-logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(name)s - %(levelname)s - %(message)s")
-logger = logging.getLogger(__name__)
-
-
-def setup_python_path():
-    """Ensure the repository root directory is on *sys.path* so that the
-    ``mindsdb`` package (located at <repo>/mindsdb) can be imported when this
-    helper script is executed from inside *mindsdb/api/a2a*.
-    """
-
-    # Absolute path to *this* file
-    this_file_dir = os.path.dirname(os.path.abspath(__file__))
-
-    # Walk three levels up:  a2a/ -> api/ -> mindsdb/ -> <repo_root>
-    repo_root = os.path.abspath(os.path.join(this_file_dir, os.pardir, os.pardir, os.pardir))
-
-    # Prepend to PYTHONPATH if not already present
-    if repo_root not in sys.path:
-        sys.path.insert(0, repo_root)
-
-    # Add the a2a directory to the Python path so that 'common' can be imported
-    if this_file_dir not in sys.path:
-        sys.path.insert(0, this_file_dir)
-
-    logger.info("Added %s to PYTHONPATH", repo_root)
-
-
-def main(config_override: Optional[Dict[str, Any]] = None, *args, **kwargs):
-    """
-    Run the a2a module with the correct Python path.
-    First set up the Python path, then import and run __main__.py
-
-    Args:
-        config_override: Optional configuration dictionary to override settings
-        args: Additional positional arguments
-        kwargs: Additional keyword arguments
-    """
-    # Set up Python path first
-    setup_python_path()
-
-    # Load environment variables
-    load_dotenv()
-
-    try:
-        # Import the main_with_config function from __main__.py
-        from mindsdb.api.a2a.__main__ import main_with_config
-        from mindsdb.utilities.config import config
-
-        logger.info("Successfully imported a2a module")
-
-        # Get configuration from config system or use provided override
-        a2a_config = config_override if config_override is not None else config.get("api", {}).get("a2a", {})
-
-        # Set log level if specified
-        if a2a_config.get("log_level"):
-            log_level = getattr(logging, a2a_config["log_level"].upper(), None)
-            if log_level:
-                logger.setLevel(log_level)
-                logger.info(f"Set log level to {a2a_config['log_level'].upper()}")
-
-        logger.info(f"Starting A2A with configuration: {a2a_config}")
-
-        # Call the main_with_config function with the configuration
-        main_with_config(a2a_config, *args, **kwargs)
-
-    except ImportError as e:
-        logger.error(f"Error importing a2a module: {e}")
-        sys.exit(1)
-    except Exception as e:
-        logger.error(f"Error running a2a module: {e}")
-        import traceback
-
-        logger.error(traceback.format_exc())
-        sys.exit(1)
-
-
-if __name__ == "__main__":
-    main()

mindsdb/api/common/check_auth.py

@@ -1,42 +0,0 @@
-import traceback
-
-from mindsdb.utilities import log
-
-logger = log.getLogger(__name__)
-
-
-def check_auth(username, password, scramble_func, salt, company_id, config):
-    try:
-        hardcoded_user = config['auth'].get('username')
-        hardcoded_password = config['auth'].get('password')
-        if hardcoded_password is None:
-            hardcoded_password = ''
-        hardcoded_password_hash = scramble_func(hardcoded_password, salt)
-        hardcoded_password = hardcoded_password.encode()
-
-        if password is None:
-            password = ''
-        if isinstance(password, str):
-            password = password.encode()
-
-        if username != hardcoded_user:
-            logger.warning(f'Check auth, user={username}: user mismatch')
-            return {
-                'success': False
-            }
-
-        if password != hardcoded_password and password != hardcoded_password_hash:
-            logger.warning(f'check auth, user={username}: password mismatch')
-            return {
-                'success': False
-            }
-
-        logger.info(f'Check auth, user={username}: Ok')
-        return {
-            'success': True,
-            'username': username
-        }
-    except Exception as e:
-        logger.error(f'Check auth, user={username}: ERROR')
-        logger.error(e)
-        logger.error(traceback.format_exc())

mindsdb/api/http/gunicorn_wrapper.py

@@ -1,17 +0,0 @@
-import gunicorn.app.base
-
-
-class StandaloneApplication(gunicorn.app.base.BaseApplication):
-    def __init__(self, app, options=None):
-        self.options = options or {}
-        self.application = app
-        super().__init__()
-
-    def load_config(self):
-        config = {key: value for key, value in self.options.items()
-                  if key in self.cfg.settings and value is not None}
-        for key, value in config.items():
-            self.cfg.set(key.lower(), value)
-
-    def load(self):
-        return self.application

mindsdb/api/mcp/start.py

@@ -1,205 +0,0 @@
-import os
-from typing import Any
-from textwrap import dedent
-from contextlib import asynccontextmanager
-from collections.abc import AsyncIterator
-from dataclasses import dataclass
-
-import uvicorn
-import anyio
-from mcp.server.fastmcp import FastMCP
-from starlette.middleware.base import BaseHTTPMiddleware
-from starlette.requests import Request
-from starlette.responses import Response
-
-from mindsdb.api.mysql.mysql_proxy.classes.fake_mysql_proxy import FakeMysqlProxy
-from mindsdb.api.executor.data_types.response_type import RESPONSE_TYPE as SQL_RESPONSE_TYPE
-from mindsdb.utilities import log
-from mindsdb.utilities.log import get_uvicorn_logging_config
-from mindsdb.utilities.config import Config
-from mindsdb.interfaces.storage import db
-
-logger = log.getLogger(__name__)
-
-
-@dataclass
-class AppContext:
-    db: Any
-
-
-@asynccontextmanager
-async def app_lifespan(server: FastMCP) -> AsyncIterator[AppContext]:
-    """Manage application lifecycle with type-safe context"""
-    # Initialize on startup
-    db.init()
-    try:
-        yield AppContext(db=db)
-    finally:
-        # TODO: We need better way to handle this in storage/db.py
-        pass
-
-
-# Configure server with lifespan
-mcp = FastMCP(
-    "MindsDB",
-    lifespan=app_lifespan,
-    dependencies=["mindsdb"],  # Add any additional dependencies
-)
-# MCP Queries
-LISTING_QUERY = "SHOW DATABASES"
-
-
-query_tool_description = dedent("""\
-    Executes a SQL query against MindsDB.
-
-    A database must be specified either in the `context` parameter or directly in the query string (e.g., `SELECT * FROM my_database.my_table`). Queries like `SELECT * FROM my_table` will fail without a `context`.
-
-    Args:
-        query (str): The SQL query to execute.
-        context (dict, optional): The default database context. For example, `{"db": "my_postgres"}`.
-
-    Returns:
-        A dictionary describing the result.
-        - For a successful query with no data to return (e.g., an `UPDATE` statement), the response is `{"type": "ok"}`.
-        - If the query returns tabular data, the response is a dictionary containing `data` (a list of rows) and `column_names` (a list of column names). For example: `{"type": "table", "data": [[1, "a"], [2, "b"]], "column_names": ["column_a", "column_b"]}`.
-        - In case of an error, a response is `{"type": "error", "error_message": "the error message"}`.
-""")
-
-
-@mcp.tool(name="query", description=query_tool_description)
-def query(query: str, context: dict | None = None) -> dict[str, Any]:
-    """Execute a SQL query against MindsDB
-
-    Args:
-        query: The SQL query to execute
-        context: Optional context parameters for the query
-
-    Returns:
-        Dict containing the query results or error information
-    """
-
-    if context is None:
-        context = {}
-
-    logger.debug(f"Incoming MCP query: {query}")
-
-    mysql_proxy = FakeMysqlProxy()
-    mysql_proxy.set_context(context)
-
-    try:
-        result = mysql_proxy.process_query(query)
-
-        if result.type == SQL_RESPONSE_TYPE.OK:
-            return {"type": SQL_RESPONSE_TYPE.OK}
-
-        if result.type == SQL_RESPONSE_TYPE.TABLE:
-            return {
-                "type": SQL_RESPONSE_TYPE.TABLE,
-                "data": result.result_set.to_lists(json_types=True),
-                "column_names": [column.alias or column.name for column in result.result_set.columns],
-            }
-        else:
-            return {"type": SQL_RESPONSE_TYPE.ERROR, "error_code": 0, "error_message": "Unknown response type"}
-
-    except Exception as e:
-        logger.error(f"Error processing query: {str(e)}")
-        return {"type": SQL_RESPONSE_TYPE.ERROR, "error_code": 0, "error_message": str(e)}
-
-
-list_databases_tool_description = (
-    "Returns a list of all database connections currently available in MindsDB. "
-    + "The tool takes no parameters and responds with a list of database names, "
-    + 'for example: ["my_postgres", "my_mysql", "test_db"].'
-)
-
-
-@mcp.tool(name="list_databases", description=list_databases_tool_description)
-def list_databases() -> list[str]:
-    """
-    List all databases in MindsDB
-
-    Returns:
-       list[str]: list of databases
-    """
-
-    mysql_proxy = FakeMysqlProxy()
-
-    try:
-        result = mysql_proxy.process_query(LISTING_QUERY)
-        if result.type == SQL_RESPONSE_TYPE.ERROR:
-            return {
-                "type": "error",
-                "error_code": result.error_code,
-                "error_message": result.error_message,
-            }
-
-        elif result.type == SQL_RESPONSE_TYPE.OK:
-            return {"type": "ok"}
-
-        elif result.type == SQL_RESPONSE_TYPE.TABLE:
-            data = result.result_set.to_lists(json_types=True)
-            data = [val[0] for val in data]
-            return data
-
-    except Exception as e:
-        return {
-            "type": "error",
-            "error_code": 0,
-            "error_message": str(e),
-        }
-
-
-class CustomAuthMiddleware(BaseHTTPMiddleware):
-    """Custom middleware to handle authentication basing on header 'Authorization'"""
-
-    async def dispatch(self, request: Request, call_next):
-        mcp_access_token = os.environ.get("MINDSDB_MCP_ACCESS_TOKEN")
-        if mcp_access_token is not None:
-            auth_token = request.headers.get("Authorization", "").partition("Bearer ")[-1]
-            if mcp_access_token != auth_token:
-                return Response(status_code=401, content="Unauthorized", media_type="text/plain")
-
-        response = await call_next(request)
-
-        return response
-
-
-async def run_sse_async() -> None:
-    """Run the server using SSE transport."""
-    starlette_app = mcp.sse_app()
-    starlette_app.add_middleware(CustomAuthMiddleware)
-
-    config = uvicorn.Config(
-        starlette_app,
-        host=mcp.settings.host,
-        port=mcp.settings.port,
-        log_level=mcp.settings.log_level.lower(),
-        log_config=get_uvicorn_logging_config("uvicorn_mcp"),
-    )
-    server = uvicorn.Server(config)
-    await server.serve()
-
-
-def start(*args, **kwargs):
-    """Start the MCP server
-    Args:
-        host (str): Host to bind to
-        port (int): Port to listen on
-    """
-    config = Config()
-    port = int(config["api"].get("mcp", {}).get("port", 47337))
-    host = config["api"].get("mcp", {}).get("host", "127.0.0.1")
-
-    logger.info(f"Starting MCP server on {host}:{port}")
-    mcp.settings.host = host
-    mcp.settings.port = port
-
-    try:
-        anyio.run(run_sse_async)
-    except Exception as e:
-        logger.error(f"Error starting MCP server: {str(e)}")
-        raise
-
-
-if __name__ == "__main__":
-    start()

mindsdb/api/mongo/classes/__init__.py

@@ -1,5 +0,0 @@
-from .responder_collection import RespondersCollection
-from .responder import Responder
-from .session import Session
-
-__all__ = ['RespondersCollection', 'Responder', 'Session']

mindsdb/api/mongo/classes/query_sql.py

@@ -1,19 +0,0 @@
-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', config.get('default_project'))
-
-    command_executor = ExecuteCommands(sql_session)
-    ret = command_executor.execute_command(ast_query)
-    if ret.error_code is not None:
-        raise Exception(ret.error_message)
-
-    if ret.data is None:
-        # return no data
-        return []
-
-    return list(ret.data.get_records())

mindsdb/api/mongo/classes/responder.py

@@ -1,45 +0,0 @@
-class Responder():
-    def __init__(self, when=None, result=None):
-        if when is not None:
-            self.when = when
-        if result is not None:
-            self.result = result
-        if not hasattr(self, 'when') or (not isinstance(self.when, dict) and not callable(self.when)):
-            raise ValueError("Responder attr 'when' must be dict or function.")
-        if not hasattr(self, 'result') or (not isinstance(self.result, dict) and not callable(self.result)):
-            raise ValueError("Responder attr 'result' must be dict or function.")
-
-    def match(self, query):
-        """ check, if this 'responder' can be used to answer or current request
-
-        query (dict): request document
-
-        return bool
-        """
-        if isinstance(self.when, dict):
-            for key, value in self.when.items():
-                if key not in query:
-                    return False
-                if callable(value):
-                    if not value(query[key]):
-                        return False
-                elif value != query[key]:
-                    return False
-            return True
-        else:
-            return self.when(query)
-
-    def handle(self, query, args, env, session):
-        """ making answer based on params:
-
-        query (dict): document(s) from request
-        args (dict): all other significant information from request: flags, collection name, rows to return, etc
-        env (dict): config, model_controller instance, and other mindsdb related stuff
-        session (object): current session
-
-        returns documents as dict or list of dicts
-        """
-        if isinstance(self.result, dict):
-            return self.result
-        else:
-            return self.result(query, args, env, session)

mindsdb/api/mongo/classes/responder_collection.py

@@ -1,34 +0,0 @@
-from .responder import Responder
-from mindsdb.utilities import log
-
-logger = log.getLogger(__name__)
-
-
-class RespondersCollection():
-    def __init__(self):
-        self.responders = []
-
-    def find_match(self, query):
-        for r in self.responders:
-            if r.match(query):
-                return r
-
-        msg = f'Is not responder for query: {query}'
-
-        class ErrorResponder(Responder):
-            when = {}
-
-            result = {
-                "ok": 0.0,
-                "errmsg": msg,
-                "code": 59,
-                "codeName": "CommandNotFound"
-            }
-
-        logger.error(msg)
-        return ErrorResponder()
-
-    def add(self, when, result):
-        self.responders.append(
-            Responder(when, result)
-        )

mindsdb/api/mongo/classes/scram.py

@@ -1,86 +0,0 @@
-# https://stackoverflow.com/questions/29298346/xmpp-sasl-scram-sha1-authentication
-# https://tools.ietf.org/html/rfc5802
-# https://tools.ietf.org/html/rfc7677
-
-import base64
-import hashlib
-import hmac
-import os
-
-from pymongo.auth import _password_digest, _xor, saslprep
-
-
-class Scram():
-    ''' implementation of server-side SCRAM-SHA-1 and SCRAM-SHA-256 auth for mongodb
-    '''
-
-    def __init__(self, method='sha1', get_salted_password=None):
-        self.get_salted_password = get_salted_password
-        self.snonce = base64.b64encode(os.urandom(24)).decode()
-        self.iterations = 4096
-        self.messages = []
-
-        if method == 'sha1':
-            self.method_str = 'sha1'
-            self.method_func = hashlib.sha1
-            self.salt = base64.b64encode(os.urandom(16))
-        elif method == 'sha256':
-            self.method_str = 'sha256'
-            self.method_func = hashlib.sha256
-            self.salt = base64.b64encode(os.urandom(28))
-
-    def process_client_first_message(self, payload):
-        payload = payload[3:]
-        payload_parts = self._split_payload(payload)
-        self.client_user = payload_parts['n']
-
-        if self.get_salted_password is not None:
-            salt_bytes, self.salted_password = self.get_salted_password(self.client_user, self.method_str)
-            self.salt = base64.b64encode(salt_bytes)
-        else:
-            self.salted_password = self.salt_password()
-
-        self.unonce = payload_parts['r']
-        self.messages.append(payload)
-
-        responce_msg = f"r={self.unonce}{self.snonce},s={self.salt.decode()},i={self.iterations}"
-        self.messages.append(responce_msg)
-        return responce_msg
-
-    def process_client_second_message(self, payload):
-        self.messages.append(payload[:payload.rfind(',p=')])    # without 'p' part
-
-        messages = ','.join(self.messages)
-        server_key = self._hmac(self.salted_password, b'Server Key')
-        server_signature = self._hmac(server_key, messages.encode('utf-8'))
-
-        client_key = self._hmac(self.salted_password, b'Client Key')
-        stored_key = self.method_func(client_key).digest()
-        client_signature = self._hmac(stored_key, messages.encode('utf-8'))
-        expected_client_proof = base64.b64encode(_xor(client_key, client_signature)).decode()
-
-        income_client_proof = payload[payload.rfind(',p=') + 3:]
-
-        if expected_client_proof != income_client_proof:
-            raise Exception('wrong password')
-
-        return f'v={base64.b64encode(server_signature).decode()}'
-
-    def _hmac(self, key, msg):
-        return hmac.new(key, msg, digestmod=self.method_func).digest()
-
-    def salt_password(self, user, password):
-        if self.method_str == 'sha1':
-            password = _password_digest(user, password).encode("utf-8")
-        elif self.method_str == 'sha256':
-            password = saslprep(password).encode("utf-8")
-
-        return hashlib.pbkdf2_hmac(
-            self.method_str, password, base64.b64decode(self.salt), self.iterations
-        )
-
-    def _split_payload(self, payload):
-        parts = {}
-        for part in [x for x in payload.split(',') if len(x) > 0]:
-            parts[part[0]] = part[2:]
-        return parts

mindsdb/api/mongo/classes/session.py

@@ -1,23 +0,0 @@
-import base64
-
-from mindsdb.api.mongo.classes.scram import Scram
-
-
-class Session():
-    def __init__(self, server_mindsdb_env):
-        self.config = server_mindsdb_env['config']
-        self.mindsdb_env = {'company_id': None}
-        self.mindsdb_env.update(server_mindsdb_env)
-
-    def init_scram(self, method):
-        self.scram = Scram(method=method, get_salted_password=self.get_salted_password)
-
-    def get_salted_password(self, username, method=None):
-        real_user = self.config['auth'].get('username', '')
-        password = self.config['auth'].get('password', '')
-        if username != real_user:
-            raise Exception(f'Wrong username {username}')
-
-        salted_password = self.scram.salt_password(real_user, password)
-
-        return base64.b64decode(self.scram.salt), salted_password

mindsdb/api/mongo/functions/__init__.py

@@ -1,19 +0,0 @@
-import bson
-
-
-def is_true(val):
-    return bool(val) is True
-
-
-def is_false(val):
-    return bool(val) is False
-
-
-def int_to_objectid(n):
-    s = str(n)
-    s = '0' * (24 - len(s)) + s
-    return bson.ObjectId(s)
-
-
-def objectid_to_int(obj):
-    return int(str(obj))

mindsdb/api/mongo/responders/__init__.py

@@ -1,73 +0,0 @@
-from .whatsmyuri import responder as responder_whatsmyuri
-from .buildinfo import responder as responder_buildinfo
-from .is_master import responder as responder_is_master
-from .is_master_lower import responder as responder_is_master_lower
-from .replsetgetstatus import responder as responder_replsetgetstatus
-from .getlog import responder as responder_getlog
-from .add_shard import responder as responder_add_shard
-from .update_range_deletions import responder as responder_update_range_deletions
-from .recv_chunk_start import responder as responder_recv_chunk_start
-from .connection_status import responder as responder_connection_status
-from .get_cmd_line_opts import responder as responder_get_cmd_line_opts
-from .host_info import responder as responder_host_info
-from .db_stats import responder as responder_db_stats
-from .coll_stats import responder as responder_coll_stats
-from .count import responder as responder_count
-from .aggregate import responder as responder_aggregate
-from .get_free_monitoring_status import responder as responder_get_free_monitoring_status
-from .end_sessions import responder as responder_end_sessions
-from .ping import responder as responder_ping
-from .get_parameter import responder as responder_get_parameter
-
-from .list_indexes import responder as responder_list_indexes
-from .list_collections import responder as responder_list_collections
-from .list_databases import responder as responder_list_databases
-
-from .find import responder as responder_find
-from .insert import responder as responder_insert
-from .delete import responder as responder_delete
-from .describe import responder as responder_describe
-
-from .sasl_start import responder as sasl_start
-from .sasl_continue import responder as sasl_continue
-
-from .company_id import responder as responder_company_id
-
-
-responders = [
-    # service queries
-    responder_whatsmyuri,
-    responder_buildinfo,
-    responder_is_master,
-    responder_is_master_lower,
-    responder_replsetgetstatus,
-    responder_getlog,
-    responder_add_shard,                # 4.4
-    responder_update_range_deletions,   # 4.4
-    responder_recv_chunk_start,         # 4.4
-    responder_connection_status,
-    responder_get_cmd_line_opts,
-    responder_host_info,
-    responder_db_stats,
-    responder_coll_stats,
-    responder_count,
-    responder_aggregate,
-    responder_get_free_monitoring_status,
-    responder_end_sessions,
-    responder_ping,
-    responder_get_parameter,
-
-    # user queries
-    responder_list_indexes,
-    responder_list_collections,
-    responder_list_databases,
-    responder_find,
-    responder_insert,
-    responder_delete,
-    responder_describe,
-    # auth
-    sasl_start,
-    sasl_continue,
-    # cloud
-    responder_company_id
-]

mindsdb/api/mongo/responders/add_shard.py

@@ -1,13 +0,0 @@
-from mindsdb.api.mongo.classes import Responder
-import mindsdb.api.mongo.functions as helpers
-
-
-class Responce(Responder):
-    when = {'_addShard': helpers.is_true}
-
-    result = {
-        "ok": 1
-    }
-
-
-responder = Responce()