MindsDB 25.9.1.2__py3-none-any.whl → 25.9.3rc1__py3-none-any.whl

mindsdb/api/http/namespaces/knowledge_bases.py

@@ -3,6 +3,7 @@ from http import HTTPStatus
 from flask import request
 from flask_restx import Resource
 from langchain_text_splitters import MarkdownHeaderTextSplitter
+from mindsdb_sql_parser.ast import Identifier
 
 from mindsdb.api.http.namespaces.configs.projects import ns_conf
 from mindsdb.api.executor.controllers.session_controller import SessionController
@@ -24,12 +25,10 @@ from mindsdb.metrics.metrics import api_endpoint_metrics
 from mindsdb.interfaces.database.projects import ProjectController
 from mindsdb.interfaces.knowledge_base.controller import KnowledgeBaseTable
 from mindsdb.utilities import log
-from mindsdb.utilities.exception import EntityNotExistsError
+from mindsdb.utilities.exception import EntityNotExistsError, EntityExistsError
 from mindsdb.integrations.utilities.rag.settings import DEFAULT_LLM_MODEL, DEFAULT_RAG_PROMPT_TEMPLATE
 
 
-from mindsdb_sql_parser.ast import Identifier
-
 logger = log.getLogger(__name__)
 
 
@@ -133,6 +132,8 @@ class KnowledgeBasesResource(Resource):
             )
         except ValueError as e:
             return http_error(HTTPStatus.BAD_REQUEST, "Invalid preprocessing configuration", str(e))
+        except EntityExistsError as e:
+            return http_error(HTTPStatus.BAD_REQUEST, "Knowledge base already exists", str(e))
 
         return new_kb.as_dict(session.show_secrets), HTTPStatus.CREATED
 
@@ -241,17 +242,17 @@ class KnowledgeBaseResource(Resource):
                 table.insert_query_result(kb_data["query"], project_name)
 
         except ExecutorException as e:
-            logger.error(f"Error during preprocessing and insertion: {str(e)}")
+            logger.exception("Error during preprocessing and insertion:")
             return http_error(
                 HTTPStatus.BAD_REQUEST,
                 "Invalid SELECT query",
-                f'Executing "query" failed. Needs to be a valid SELECT statement that returns data: {str(e)}',
+                f'Executing "query" failed. Needs to be a valid SELECT statement that returns data: {e}',
             )
 
         except Exception as e:
-            logger.error(f"Error during preprocessing and insertion: {str(e)}")
+            logger.exception("Error during preprocessing and insertion:")
             return http_error(
-                HTTPStatus.BAD_REQUEST, "Preprocessing Error", f"Error during preprocessing and insertion: {str(e)}"
+                HTTPStatus.BAD_REQUEST, "Preprocessing Error", f"Error during preprocessing and insertion: {e}"
             )
 
         return "", HTTPStatus.OK

mindsdb/api/http/namespaces/models.py

@@ -4,7 +4,6 @@ import json
 
 from flask import request
 from flask_restx import Resource
-from sqlalchemy.exc import NoResultFound
 import pandas as pd
 
 from mindsdb.api.http.namespaces.configs.projects import ns_conf
@@ -15,71 +14,65 @@ from mindsdb.interfaces.model.functions import PredictorRecordNotFound
 from mindsdb.interfaces.storage.db import Predictor
 from mindsdb_sql_parser import parse_sql
 from mindsdb_sql_parser.ast.mindsdb import CreatePredictor
+from mindsdb.utilities.exception import EntityNotExistsError
+from mindsdb.utilities import log
 
+logger = log.getLogger(__name__)
 
-@ns_conf.route('/<project_name>/models')
+
+@ns_conf.route("/<project_name>/models")
 class ModelsList(Resource):
-    @ns_conf.doc('list_models')
-    @api_endpoint_metrics('GET', '/models')
+    @ns_conf.doc("list_models")
+    @api_endpoint_metrics("GET", "/models")
     def get(self, project_name):
-        ''' List all models '''
+        """List all models"""
         session = SessionController()
 
         try:
             session.database_controller.get_project(project_name)
-        except NoResultFound:
-            return http_error(
-                HTTPStatus.NOT_FOUND,
-                'Project not found',
-                f'Project name {project_name} does not exist')
+        except EntityNotExistsError:
+            return http_error(HTTPStatus.NOT_FOUND, "Project not found", f"Project name {project_name} does not exist")
 
         return session.model_controller.get_models(with_versions=True, project_name=project_name)
 
-    @ns_conf.doc('train_model')
-    @api_endpoint_metrics('POST', '/models')
+    @ns_conf.doc("train_model")
+    @api_endpoint_metrics("POST", "/models")
     def post(self, project_name):
-        '''Creates a new model and trains it'''
+        """Creates a new model and trains it"""
         session = SessionController()
 
-        if 'query' not in request.json:
-            return http_error(
-                HTTPStatus.BAD_REQUEST,
-                'Query required',
-                'Missing "query" SQL statement')
-        query = request.json['query']
+        if "query" not in request.json:
+            return http_error(HTTPStatus.BAD_REQUEST, "Query required", 'Missing "query" SQL statement')
+        query = request.json["query"]
 
         project_datanode = session.datahub.get(project_name)
         if project_datanode is None:
-            return http_error(
-                HTTPStatus.NOT_FOUND,
-                'Project not found',
-                f'Project name {project_name} does not exist')
+            return http_error(HTTPStatus.NOT_FOUND, "Project not found", f"Project name {project_name} does not exist")
 
         try:
             create_statement = parse_sql(query)
         except Exception:
             return http_error(
-                HTTPStatus.BAD_REQUEST,
-                'Invalid query string',
-                f'SQL CREATE statement is invalid: {query}')
+                HTTPStatus.BAD_REQUEST, "Invalid query string", f"SQL CREATE statement is invalid: {query}"
+            )
 
         if type(create_statement) is not CreatePredictor:
             return http_error(
                 HTTPStatus.BAD_REQUEST,
-                'Invalid CREATE SQL statement',
-                f'SQL statement is not a CREATE model statement: {query}')
+                "Invalid CREATE SQL statement",
+                f"SQL statement is not a CREATE model statement: {query}",
+            )
 
         model_name = create_statement.name.parts[1].lower()
         try:
             session.model_controller.get_model(model_name, project_name=project_name)
             return http_error(
-                HTTPStatus.CONFLICT,
-                'Model already exists',
-                f'Model with name {model_name} already exists')
+                HTTPStatus.CONFLICT, "Model already exists", f"Model with name {model_name} already exists"
+            )
         except PredictorRecordNotFound:
             pass
 
-        ml_integration = 'lightwood'
+        ml_integration = "lightwood"
         if create_statement.using is not None:
             # Convert using to lowercase
             create_statement.using = {k.lower(): v for k, v in create_statement.using.items()}
@@ -89,60 +82,55 @@ class ModelsList(Resource):
             ml_handler = session.integration_controller.get_ml_handler(ml_integration)
         except Exception:
             return http_error(
-                HTTPStatus.NOT_FOUND,
-                'ML handler not found',
-                f'Cannot find ML handler with name {ml_integration}')
+                HTTPStatus.NOT_FOUND, "ML handler not found", f"Cannot find ML handler with name {ml_integration}"
+            )
 
         try:
             model_df = session.model_controller.create_model(create_statement, ml_handler)
             # Consistent format with GET /projects/<project_name>/models/<model_name>
             return {
-                'name': model_df.at[0, 'NAME'],
-                'accuracy': None,
-                'active': model_df.at[0, 'ACTIVE'],
-                'version': model_df.at[0, 'VERSION'],
-                'status': model_df.at[0, 'STATUS'],
-                'predict': model_df.at[0, 'PREDICT'],
-                'mindsdb_version': model_df.at[0, 'MINDSDB_VERSION'],
-                'error': model_df.at[0, 'ERROR'],
-                'fetch_data_query': model_df.at[0, 'SELECT_DATA_QUERY'],
-                'problem_definition': model_df.at[0, 'TRAINING_OPTIONS']
+                "name": model_df.at[0, "NAME"],
+                "accuracy": None,
+                "active": model_df.at[0, "ACTIVE"],
+                "version": model_df.at[0, "VERSION"],
+                "status": model_df.at[0, "STATUS"],
+                "predict": model_df.at[0, "PREDICT"],
+                "mindsdb_version": model_df.at[0, "MINDSDB_VERSION"],
+                "error": model_df.at[0, "ERROR"],
+                "fetch_data_query": model_df.at[0, "SELECT_DATA_QUERY"],
+                "problem_definition": model_df.at[0, "TRAINING_OPTIONS"],
             }, HTTPStatus.CREATED
         except Exception as e:
+            logger.exception("Something went wrong while creating and training model")
             return http_error(
                 HTTPStatus.INTERNAL_SERVER_ERROR,
-                'Unable to train model',
-                f'Something went wrong while creating and training model {model_name}: {e}')
+                "Unable to train model",
+                f"Something went wrong while creating and training model {model_name}: {e}",
+            )
 
 
-@ns_conf.route('/<project_name>/models/<model_name>')
-@ns_conf.param('project_name', 'Name of the project')
-@ns_conf.param('model_name', 'Name of the model')
+@ns_conf.route("/<project_name>/models/<model_name>")
+@ns_conf.param("project_name", "Name of the project")
+@ns_conf.param("model_name", "Name of the model")
 class ModelResource(Resource):
-    @ns_conf.doc('get_model')
-    @api_endpoint_metrics('GET', '/models/model')
+    @ns_conf.doc("get_model")
+    @api_endpoint_metrics("GET", "/models/model")
     def get(self, project_name, model_name):
-        '''Get a model by name and version'''
+        """Get a model by name and version"""
         session = SessionController()
 
         project_datanode = session.datahub.get(project_name)
         if project_datanode is None:
-            return http_error(
-                HTTPStatus.NOT_FOUND,
-                'Project not found',
-                f'Project name {project_name} does not exist')
+            return http_error(HTTPStatus.NOT_FOUND, "Project not found", f"Project name {project_name} does not exist")
 
         name_no_version, version = Predictor.get_name_and_version(model_name)
         try:
             return session.model_controller.get_model(name_no_version, version=version, project_name=project_name)
         except PredictorRecordNotFound:
-            return http_error(
-                HTTPStatus.NOT_FOUND,
-                'Model not found',
-                f'Model with name {model_name} not found')
+            return http_error(HTTPStatus.NOT_FOUND, "Model not found", f"Model with name {model_name} not found")
 
-    @ns_conf.doc('update_model')
-    @api_endpoint_metrics('PUT', '/models/model')
+    @ns_conf.doc("update_model")
+    @api_endpoint_metrics("PUT", "/models/model")
     def put(self, project_name, model_name):
         """Update model"""
 
@@ -150,18 +138,14 @@ class ModelResource(Resource):
 
         project_datanode = session.datahub.get(project_name)
         if project_datanode is None:
-            return http_error(
-                HTTPStatus.NOT_FOUND,
-                'Project not found',
-                f'Project name {project_name} does not exist')
+            return http_error(HTTPStatus.NOT_FOUND, "Project not found", f"Project name {project_name} does not exist")
 
-        if 'problem_definition' not in request.json:
+        if "problem_definition" not in request.json:
             return http_error(
-                HTTPStatus.BAD_REQUEST,
-                'problem_definition required',
-                'Missing "problem_definition" field')
+                HTTPStatus.BAD_REQUEST, "problem_definition required", 'Missing "problem_definition" field'
+            )
 
-        problem_definition = request.json['problem_definition']
+        problem_definition = request.json["problem_definition"]
 
         model_name, version = Predictor.get_name_and_version(model_name)
 
@@ -174,48 +158,44 @@ class ModelResource(Resource):
         )
         return session.model_controller.get_model(model_name, version=version, project_name=project_name)
 
-    @ns_conf.doc('delete_model')
-    @api_endpoint_metrics('DELETE', '/models/model')
+    @ns_conf.doc("delete_model")
+    @api_endpoint_metrics("DELETE", "/models/model")
     def delete(self, project_name, model_name):
-        '''Deletes a model by name'''
+        """Deletes a model by name"""
 
         session = SessionController()
 
         project_datanode = session.datahub.get(project_name)
         if project_datanode is None:
-            return http_error(
-                HTTPStatus.NOT_FOUND,
-                'Project not found',
-                f'Project name {project_name} does not exist')
+            return http_error(HTTPStatus.NOT_FOUND, "Project not found", f"Project name {project_name} does not exist")
 
         name_no_version, version = Predictor.get_name_and_version(model_name)
         try:
             session.model_controller.get_model(name_no_version, version=version, project_name=project_name)
         except PredictorRecordNotFound:
-            return http_error(
-                HTTPStatus.NOT_FOUND,
-                'Model not found',
-                f'Model with name {model_name} not found')
+            return http_error(HTTPStatus.NOT_FOUND, "Model not found", f"Model with name {model_name} not found")
 
         try:
             session.model_controller.delete_model(name_no_version, project_name, version=version)
         except Exception as e:
+            logger.exception(f"Something went wrong while deleting model '{model_name}'")
             return http_error(
                 HTTPStatus.INTERNAL_SERVER_ERROR,
-                'Error deleting model',
-                f'Something went wrong while deleting {model_name}: {e}')
+                "Error deleting model",
+                f"Something went wrong while deleting {model_name}: {e}",
+            )
 
-        return '', HTTPStatus.NO_CONTENT
+        return "", HTTPStatus.NO_CONTENT
 
 
-@ns_conf.route('/<project_name>/models/<model_name>/predict')
-@ns_conf.param('project_name', 'Name of the project')
-@ns_conf.param('model_name', 'Name of the model')
+@ns_conf.route("/<project_name>/models/<model_name>/predict")
+@ns_conf.param("project_name", "Name of the project")
+@ns_conf.param("model_name", "Name of the model")
 class ModelPredict(Resource):
-    @ns_conf.doc('post_model_predict')
-    @api_endpoint_metrics('POST', '/models/model/predict')
+    @ns_conf.doc("post_model_predict")
+    @api_endpoint_metrics("POST", "/models/model/predict")
     def post(self, project_name, model_name):
-        '''Call prediction'''
+        """Call prediction"""
 
         name_no_version, version = Predictor.get_name_and_version(model_name)
 
@@ -223,23 +203,19 @@ class ModelPredict(Resource):
         project_datanode = session.datahub.get(project_name)
         if project_datanode is None:
             return http_error(
-                HTTPStatus.NOT_FOUND,
-                'Project not found',
-                f'Project with name {project_name} does not exist')
+                HTTPStatus.NOT_FOUND, "Project not found", f"Project with name {project_name} does not exist"
+            )
 
         try:
             session.model_controller.get_model(name_no_version, version=version, project_name=project_name)
         except PredictorRecordNotFound:
-            return http_error(
-                HTTPStatus.NOT_FOUND,
-                'Model not found',
-                f'Model with name {model_name} not found')
+            return http_error(HTTPStatus.NOT_FOUND, "Model not found", f"Model with name {model_name} not found")
 
-        data = request.json['data']
+        data = request.json["data"]
         if isinstance(data, str):
             # Support object or serialized object.
             data = json.loads(data)
-        params = request.json.get('params')
+        params = request.json.get("params")
 
         predictions = project_datanode.predict(
             model_name=name_no_version,
@@ -248,50 +224,42 @@ class ModelPredict(Resource):
             params=params,
         )
 
-        return predictions.to_dict('records')
+        return predictions.to_dict("records")
 
 
-@ns_conf.route('/<project_name>/models/<model_name>/describe')
-@ns_conf.param('project_name', 'Name of the project')
-@ns_conf.param('model_name', 'Name of the model')
+@ns_conf.route("/<project_name>/models/<model_name>/describe")
+@ns_conf.param("project_name", "Name of the project")
+@ns_conf.param("model_name", "Name of the model")
 class ModelDescribe(Resource):
-    @ns_conf.doc('describe_model')
-    @api_endpoint_metrics('GET', '/models/model/describe')
+    @ns_conf.doc("describe_model")
+    @api_endpoint_metrics("GET", "/models/model/describe")
     def get(self, project_name, model_name):
-        '''Describes a model'''
+        """Describes a model"""
         session = SessionController()
 
         project_datanode = session.datahub.get(project_name)
         if project_datanode is None:
-            return http_error(
-                HTTPStatus.NOT_FOUND,
-                'Project not found',
-                f'Project name {project_name} does not exist')
+            return http_error(HTTPStatus.NOT_FOUND, "Project not found", f"Project name {project_name} does not exist")
 
         name_no_version, version = Predictor.get_name_and_version(model_name)
 
         try:
             session.model_controller.get_model(name_no_version, version=version, project_name=project_name)
         except PredictorRecordNotFound:
-            return http_error(
-                HTTPStatus.NOT_FOUND,
-                'Model not found',
-                f'Model with name {model_name} not found')
+            return http_error(HTTPStatus.NOT_FOUND, "Model not found", f"Model with name {model_name} not found")
 
         attribute = None
-        if 'attribute' in request.json:
-            attribute = request.json['attribute']
+        if "attribute" in request.json:
+            attribute = request.json["attribute"]
 
         try:
             description_df = session.model_controller.describe_model(
-                session,
-                project_name,
-                name_no_version,
-                attribute,
-                version=version)
-            return description_df.to_dict('records')
+                session, project_name, name_no_version, attribute, version=version
+            )
+            return description_df.to_dict("records")
         except Exception:
             return http_error(
                 HTTPStatus.BAD_REQUEST,
-                'ML handler unsupported',
-                f'ML handler for {model_name} does not support model description')
+                "ML handler unsupported",
+                f"ML handler for {model_name} does not support model description",
+            )

mindsdb/api/http/namespaces/projects.py

@@ -1,7 +1,6 @@
 from http import HTTPStatus
 
 from flask_restx import Resource
-from sqlalchemy.exc import NoResultFound
 
 from mindsdb.metrics.metrics import api_endpoint_metrics
 from mindsdb.api.http.utils import http_error
@@ -10,37 +9,29 @@ from mindsdb.api.executor.controllers.session_controller import SessionControlle
 from mindsdb.utilities.exception import EntityNotExistsError
 
 
-@ns_conf.route('/')
+@ns_conf.route("/")
 class ProjectsList(Resource):
-    @ns_conf.doc('list_projects')
-    @api_endpoint_metrics('GET', '/projects')
+    @ns_conf.doc("list_projects")
+    @api_endpoint_metrics("GET", "/projects")
     def get(self):
-        ''' List all projects '''
+        """List all projects"""
         session = SessionController()
 
-        projects = [
-            {'name': i}
-            for i in session.datahub.get_projects_names()
-        ]
+        projects = [{"name": i} for i in session.datahub.get_projects_names()]
         return projects
 
 
-@ns_conf.route('/<project_name>')
+@ns_conf.route("/<project_name>")
 class ProjectsGet(Resource):
-    @ns_conf.doc('get_project')
-    @api_endpoint_metrics('GET', '/projects/project')
+    @ns_conf.doc("get_project")
+    @api_endpoint_metrics("GET", "/projects/project")
     def get(self, project_name):
-        '''Gets a project by name'''
+        """Gets a project by name"""
         session = SessionController()
 
         try:
             project = session.database_controller.get_project(project_name)
-        except (NoResultFound, EntityNotExistsError):
-            return http_error(
-                HTTPStatus.NOT_FOUND, 'Project not exists',
-                f'Project name {project_name} does not exist'
-            )
-
-        return {
-            'name': project.name
-        }
+        except EntityNotExistsError:
+            return http_error(HTTPStatus.NOT_FOUND, "Project not exists", f"Project name {project_name} does not exist")
+
+        return {"name": project.name}

mindsdb/api/http/namespaces/sql.py

@@ -1,5 +1,4 @@
 from http import HTTPStatus
-import traceback
 
 from flask import request
 from flask_restx import Resource
@@ -18,6 +17,7 @@ from mindsdb.metrics.metrics import api_endpoint_metrics
 from mindsdb.utilities import log
 from mindsdb.utilities.config import Config
 from mindsdb.utilities.context import context as ctx
+from mindsdb.utilities.exception import QueryError
 
 logger = log.getLogger(__name__)
 
@@ -29,18 +29,14 @@ class Query(Resource):
         super().__init__(*args, **kwargs)
 
     @ns_conf.doc("query")
-    @api_endpoint_metrics('POST', '/sql/query')
+    @api_endpoint_metrics("POST", "/sql/query")
     def post(self):
         query = request.json["query"]
         context = request.json.get("context", {})
 
         if isinstance(query, str) is False or isinstance(context, dict) is False:
-            return http_error(
-                HTTPStatus.BAD_REQUEST,
-                'Wrong arguments',
-                'Please provide "query" with the request.'
-            )
-        logger.debug(f'Incoming query: {query}')
+            return http_error(HTTPStatus.BAD_REQUEST, "Wrong arguments", 'Please provide "query" with the request.')
+        logger.debug(f"Incoming query: {query}")
 
         if context.get("profiling") is True:
             profiler.enable()
@@ -50,9 +46,7 @@ class Query(Resource):
         error_text = None
         error_traceback = None
 
-        profiler.set_meta(
-            query=query, api="http", environment=Config().get("environment")
-        )
+        profiler.set_meta(query=query, api="http", environment=Config().get("environment"))
         with profiler.Context("http_query_processing"):
             mysql_proxy = FakeMysqlProxy()
             mysql_proxy.set_context(context)
@@ -67,8 +61,18 @@ class Query(Resource):
                     "error_code": 0,
                     "error_message": str(e),
                 }
-                logger.error(f"Error query processing: \n{traceback.format_exc()}")
-
+                logger.warning(f"Error query processing: {e}")
+            except QueryError as e:
+                error_type = "expected" if e.is_acceptable else "unexpected"
+                query_response = {
+                    "type": SQL_RESPONSE_TYPE.ERROR,
+                    "error_code": 0,
+                    "error_message": str(e),
+                }
+                if e.is_acceptable:
+                    logger.warning(f"Query failed due to expected reason: {e}")
+                else:
+                    logger.exception("Error query processing:")
             except UnknownError as e:
                 # unclassified
                 error_type = "unexpected"
@@ -77,7 +81,7 @@ class Query(Resource):
                     "error_code": 0,
                     "error_message": str(e),
                 }
-                logger.error(f"Error query processing: \n{traceback.format_exc()}")
+                logger.exception("Error query processing:")
 
             except Exception as e:
                 error_type = "unexpected"
@@ -86,7 +90,7 @@ class Query(Resource):
                     "error_code": 0,
                     "error_message": str(e),
                 }
-                logger.error(f"Error query processing: \n{traceback.format_exc()}")
+                logger.exception("Error query processing:")
 
             if query_response.get("type") == SQL_RESPONSE_TYPE.ERROR:
                 error_type = "expected"
@@ -115,7 +119,7 @@ class Query(Resource):
 @ns_conf.param("list_databases", "lists databases of mindsdb")
 class ListDatabases(Resource):
     @ns_conf.doc("list_databases")
-    @api_endpoint_metrics('GET', '/sql/list_databases')
+    @api_endpoint_metrics("GET", "/sql/list_databases")
     def get(self):
         listing_query = "SHOW DATABASES"
         mysql_proxy = FakeMysqlProxy()
@@ -133,17 +137,21 @@ class ListDatabases(Resource):
                 listing_query_response = {"type": "ok"}
             elif result.type == SQL_RESPONSE_TYPE.TABLE:
                 listing_query_response = {
-                    "data": [{
-                        "name": db_row[0],
-                        "tables": [
-                            table_row[0]
-                            for table_row in mysql_proxy.process_query(
-                                "SHOW TABLES FROM `{}`".format(db_row[0])
-                            ).result_set.to_lists()
-                        ]
-                    } for db_row in result.result_set.to_lists()]
+                    "data": [
+                        {
+                            "name": db_row[0],
+                            "tables": [
+                                table_row[0]
+                                for table_row in mysql_proxy.process_query(
+                                    "SHOW TABLES FROM `{}`".format(db_row[0])
+                                ).result_set.to_lists()
+                            ],
+                        }
+                        for db_row in result.result_set.to_lists()
+                    ]
                 }
         except Exception as e:
+            logger.exception("Error while retrieving list of databases")
             listing_query_response = {
                 "type": "error",
                 "error_code": 0,