MindsDB 25.5.4.0__py3-none-any.whl → 25.5.4.2__py3-none-any.whl

mindsdb/api/executor/command_executor.py

@@ -65,7 +65,7 @@ from mindsdb_sql_parser.ast.mindsdb import (
     RetrainPredictor,
     UpdateAgent,
     UpdateChatBot,
-    UpdateSkill
+    UpdateSkill,
 )
 
 import mindsdb.utilities.profiler as profiler
@@ -140,18 +140,12 @@ def _get_show_where(
             )
         )
     if statement.like is not None and like_name is not None:
-        where.append(
-            BinaryOperation(
-                "like", args=[Identifier(like_name), Constant(statement.like)]
-            )
-        )
+        where.append(BinaryOperation("like", args=[Identifier(like_name), Constant(statement.like)]))
     if statement.where is not None:
         where.append(statement.where)
 
     if len(where) > 0:
-        return reduce(
-            lambda prev, next: BinaryOperation("and", args=[prev, next]), where
-        )
+        return reduce(lambda prev, next: BinaryOperation("and", args=[prev, next]), where)
     return None
 
 
@@ -184,7 +178,7 @@ class ExecuteCommands:
                 name,
                 handler=statement.handler,
                 params=statement.params,
-                if_not_exists=getattr(statement, "if_not_exists", False)
+                if_not_exists=getattr(statement, "if_not_exists", False),
             )
         elif statement_type is DropMLEngine:
             return self.answer_drop_ml_engine(statement)
@@ -199,7 +193,7 @@ class ExecuteCommands:
             # NOTE in sql 'describe table' is same as 'show columns'
             obj_type = statement.type
 
-            if obj_type is None or obj_type.upper() in ('MODEL', 'PREDICTOR'):
+            if obj_type is None or obj_type.upper() in ("MODEL", "PREDICTOR"):
                 return self.answer_describe_predictor(statement.value, database_name)
             else:
                 return self.answer_describe_object(obj_type.upper(), statement.value, database_name)
@@ -234,9 +228,7 @@ class ExecuteCommands:
                 return self.answer_select(query)
             elif sql_category == "plugins":
                 if statement.where is not None or statement.like:
-                    raise ExecutorException(
-                        "'SHOW PLUGINS' query should be used without filters"
-                    )
+                    raise ExecutorException("'SHOW PLUGINS' query should be used without filters")
                 new_statement = Select(
                     targets=[Star()],
                     from_table=Identifier(parts=["information_schema", "PLUGINS"]),
@@ -262,10 +254,7 @@ class ExecuteCommands:
                 return self.answer_select(query)
             elif sql_category in ("tables", "full tables"):
                 schema = database_name or "mindsdb"
-                if (
-                    statement.from_table is not None
-                    and statement.in_table is not None
-                ):
+                if statement.from_table is not None and statement.in_table is not None:
                     raise ExecutorException(
                         "You have an error in your SQL syntax: 'from' and 'in' cannot be used together"
                     )
@@ -277,13 +266,13 @@ class ExecuteCommands:
                     schema = statement.in_table.parts[-1]
                     statement.in_table = None
 
-                table_types = [Constant(t) for t in ['MODEL', 'BASE TABLE', 'SYSTEM VIEW', 'VIEW']]
+                table_types = [Constant(t) for t in ["MODEL", "BASE TABLE", "SYSTEM VIEW", "VIEW"]]
                 where = BinaryOperation(
                     "and",
                     args=[
                         BinaryOperation("=", args=[Identifier("table_schema"), Constant(schema)]),
-                        BinaryOperation("in", args=[Identifier("table_type"), Tuple(table_types)])
-                    ]
+                        BinaryOperation("in", args=[Identifier("table_type"), Tuple(table_types)]),
+                    ],
                 )
 
                 new_statement = Select(
@@ -294,15 +283,11 @@ class ExecuteCommands:
                         )
                     ],
                     from_table=Identifier(parts=["information_schema", "TABLES"]),
-                    where=_get_show_where(
-                        statement, like_name=f"Tables_in_{schema}", initial=where
-                    ),
+                    where=_get_show_where(statement, like_name=f"Tables_in_{schema}", initial=where),
                 )
 
                 if "FULL" in statement.modes:
-                    new_statement.targets.append(
-                        Identifier(parts=["TABLE_TYPE"], alias=Identifier("Table_type"))
-                    )
+                    new_statement.targets.append(Identifier(parts=["TABLE_TYPE"], alias=Identifier("Table_type")))
 
                 query = SQLQuery(new_statement, session=self.session, database=database_name)
                 return self.answer_select(query)
@@ -327,9 +312,7 @@ class ExecuteCommands:
                     var_name = var_name.replace("@@", "")
                     if is_session and var_name.startswith("session.") is False:
                         continue
-                    if var_name.startswith("session.") or var_name.startswith(
-                        "GLOBAL."
-                    ):
+                    if var_name.startswith("session.") or var_name.startswith("GLOBAL."):
                         name = var_name.replace("session.", "").replace("GLOBAL.", "")
                         data[name] = var_data[0]
                     elif var_name not in data:
@@ -338,28 +321,20 @@ class ExecuteCommands:
                 df = pd.DataFrame(data.items(), columns=["Variable_name", "Value"])
                 df2 = query_df(df, new_statement)
 
-                return ExecuteAnswer(
-                    data=ResultSet.from_df(df2, table_name="session_variables")
-                )
+                return ExecuteAnswer(data=ResultSet.from_df(df2, table_name="session_variables"))
             elif sql_category == "search_path":
                 return ExecuteAnswer(
                     data=ResultSet(
-                        columns=[
-                            Column(name="search_path", table_name="search_path", type="str")
-                        ],
-                        values=[['"$user", public']]
+                        columns=[Column(name="search_path", table_name="search_path", type="str")],
+                        values=[['"$user", public']],
                     )
                 )
             elif "show status like 'ssl_version'" in sql_lower:
                 return ExecuteAnswer(
                     data=ResultSet(
                         columns=[
-                            Column(
-                                name="Value", table_name="session_variables", type="str"
-                            ),
-                            Column(
-                                name="Value", table_name="session_variables", type="str"
-                            ),
+                            Column(name="Value", table_name="session_variables", type="str"),
+                            Column(name="Value", table_name="session_variables", type="str"),
                         ],
                         values=[["Ssl_version", "TLSv1.1"]],
                     )
@@ -398,23 +373,17 @@ class ExecuteCommands:
             # FIXME if have answer on that request, then DataGrip show warning '[S0022] Column 'Non_unique' not found.'
             elif "show create table" in sql_lower:
                 # SHOW CREATE TABLE `MINDSDB`.`predictors`
-                table = sql[sql.rfind(".") + 1:].strip(" .;\n\t").replace("`", "")
+                table = sql[sql.rfind(".") + 1 :].strip(" .;\n\t").replace("`", "")
                 return self.answer_show_create_table(table)
             elif sql_category in ("character set", "charset"):
                 new_statement = Select(
                     targets=[
                         Identifier("CHARACTER_SET_NAME", alias=Identifier("Charset")),
-                        Identifier(
-                            "DEFAULT_COLLATE_NAME", alias=Identifier("Description")
-                        ),
-                        Identifier(
-                            "DESCRIPTION", alias=Identifier("Default collation")
-                        ),
+                        Identifier("DEFAULT_COLLATE_NAME", alias=Identifier("Description")),
+                        Identifier("DESCRIPTION", alias=Identifier("Default collation")),
                         Identifier("MAXLEN", alias=Identifier("Maxlen")),
                     ],
-                    from_table=Identifier(
-                        parts=["INFORMATION_SCHEMA", "CHARACTER_SETS"]
-                    ),
+                    from_table=Identifier(parts=["INFORMATION_SCHEMA", "CHARACTER_SETS"]),
                     where=_get_show_where(statement, like_name="CHARACTER_SET_NAME"),
                 )
                 query = SQLQuery(new_statement, session=self.session, database=database_name)
@@ -467,9 +436,18 @@ class ExecuteCommands:
                     database_name=database_name,
                 )
 
-            elif sql_category in ("agents", "jobs", "skills", "chatbots", "triggers", "views",
-                                  "knowledge_bases", "knowledge bases", "predictors", "models"):
-
+            elif sql_category in (
+                "agents",
+                "jobs",
+                "skills",
+                "chatbots",
+                "triggers",
+                "views",
+                "knowledge_bases",
+                "knowledge bases",
+                "predictors",
+                "models",
+            ):
                 if sql_category == "knowledge bases":
                     sql_category = "knowledge_bases"
 
@@ -480,25 +458,21 @@ class ExecuteCommands:
                 if statement.from_table is not None:
                     db_name = statement.from_table.parts[-1]
 
-                where = BinaryOperation(op='=', args=[Identifier('project'), Constant(db_name)])
+                where = BinaryOperation(op="=", args=[Identifier("project"), Constant(db_name)])
 
                 select_statement = Select(
                     targets=[Star()],
-                    from_table=Identifier(
-                        parts=["information_schema", sql_category]
-                    ),
+                    from_table=Identifier(parts=["information_schema", sql_category]),
                     where=_get_show_where(statement, like_name="name", initial=where),
                 )
                 query = SQLQuery(select_statement, session=self.session)
                 return self.answer_select(query)
 
             elif sql_category == "projects":
-                where = BinaryOperation(op='=', args=[Identifier('type'), Constant('project')])
+                where = BinaryOperation(op="=", args=[Identifier("type"), Constant("project")])
                 select_statement = Select(
-                    targets=[Identifier(parts=["NAME"], alias=Identifier('project'))],
-                    from_table=Identifier(
-                        parts=["information_schema", "DATABASES"]
-                    ),
+                    targets=[Identifier(parts=["NAME"], alias=Identifier("project"))],
+                    from_table=Identifier(parts=["information_schema", "DATABASES"]),
                     where=_get_show_where(statement, like_name="project", from_name="project", initial=where),
                 )
 
@@ -565,9 +539,7 @@ class ExecuteCommands:
                 return self.answer_update_model_version(statement.value, database_name)
 
             else:
-                logger.warning(
-                    f"SQL statement is not processable, return OK package: {sql}"
-                )
+                logger.warning(f"SQL statement is not processable, return OK package: {sql}")
                 return ExecuteAnswer()
         elif statement_type is Use:
             db_name = statement.value.parts[-1]
@@ -584,26 +556,16 @@ class ExecuteCommands:
             return self.answer_drop_view(statement, database_name)
         elif statement_type is Delete:
             query = SQLQuery(statement, session=self.session, database=database_name)
-            return ExecuteAnswer(
-                affected_rows=query.fetched_data.affected_rows
-            )
+            return ExecuteAnswer(affected_rows=query.fetched_data.affected_rows)
         elif statement_type is Insert:
             query = SQLQuery(statement, session=self.session, database=database_name)
             if query.fetched_data.length() > 0:
                 return self.answer_select(query)
-            return ExecuteAnswer(
-                affected_rows=query.fetched_data.affected_rows
-            )
+            return ExecuteAnswer(affected_rows=query.fetched_data.affected_rows)
         elif statement_type is Update:
             query = SQLQuery(statement, session=self.session, database=database_name)
-            return ExecuteAnswer(
-                affected_rows=query.fetched_data.affected_rows
-            )
-        elif (
-            statement_type is Alter
-            and ("disable keys" in sql_lower)
-            or ("enable keys" in sql_lower)
-        ):
+            return ExecuteAnswer(affected_rows=query.fetched_data.affected_rows)
+        elif statement_type is Alter and ("disable keys" in sql_lower) or ("enable keys" in sql_lower):
             return ExecuteAnswer()
         elif statement_type is Select:
             ret = self.exec_service_function(statement, database_name)
@@ -677,11 +639,11 @@ class ExecuteCommands:
 
         command = target.op.lower()
         args = [arg.value for arg in target.args if isinstance(arg, Constant)]
-        if command == 'query_resume':
+        if command == "query_resume":
             ret = SQLQuery(None, session=self.session, query_id=args[0])
             return self.answer_select(ret)
 
-        elif command == 'query_cancel':
+        elif command == "query_cancel":
             query_context_controller.cancel_query(*args)
             return ExecuteAnswer()
 
@@ -822,25 +784,17 @@ class ExecuteCommands:
     def answer_evaluate_metric(self, statement, database_name):
         # heavy import, so we do it here on-demand
         from mindsdb_evaluator.accuracy.general import evaluate_accuracy
+
         try:
             sqlquery = SQLQuery(statement.data, session=self.session, database=database_name)
         except Exception as e:
-            raise Exception(
-                f'Nested query failed to execute with error: "{e}", please check and try again.'
-            )
+            raise Exception(f'Nested query failed to execute with error: "{e}", please check and try again.')
         df = sqlquery.fetched_data.to_df()
-        df.columns = [
-            str(t.alias) if hasattr(t, "alias") else str(t.parts[-1])
-            for t in statement.data.targets
-        ]
+        df.columns = [str(t.alias) if hasattr(t, "alias") else str(t.parts[-1]) for t in statement.data.targets]
 
         for col in ["actual", "prediction"]:
-            assert (
-                col in df.columns
-            ), f"`{col}` column was not provided, please try again."
-            assert (
-                df[col].isna().sum() == 0
-            ), f"There are missing values in the `{col}` column, please try again."
+            assert col in df.columns, f"`{col}` column was not provided, please try again."
+            assert df[col].isna().sum() == 0, f"There are missing values in the `{col}` column, please try again."
 
         metric_name = statement.name.parts[-1]
         target_series = df.pop("prediction")
@@ -861,9 +815,17 @@ class ExecuteCommands:
         )
 
     def answer_describe_object(self, obj_type: str, obj_name: Identifier, database_name: str):
-
-        project_objects = ("AGENTS", "JOBS", "SKILLS", "CHATBOTS", "TRIGGERS", "VIEWS",
-                           "KNOWLEDGE_BASES", "PREDICTORS", "MODELS")
+        project_objects = (
+            "AGENTS",
+            "JOBS",
+            "SKILLS",
+            "CHATBOTS",
+            "TRIGGERS",
+            "VIEWS",
+            "KNOWLEDGE_BASES",
+            "PREDICTORS",
+            "MODELS",
+        )
 
         global_objects = ("DATABASES", "PROJECTS", "HANDLERS", "ML_ENGINES")
 
@@ -871,39 +833,31 @@ class ExecuteCommands:
 
         # is not plural?
         if obj_type not in all_objects:
-            if obj_type + 'S' in all_objects:
-                obj_type = obj_type + 'S'
-            elif obj_type + 'ES' in all_objects:
-                obj_type = obj_type + 'ES'
+            if obj_type + "S" in all_objects:
+                obj_type = obj_type + "S"
+            elif obj_type + "ES" in all_objects:
+                obj_type = obj_type + "ES"
             else:
-                raise WrongArgumentError(f'Unknown describe type: {obj_type}')
+                raise WrongArgumentError(f"Unknown describe type: {obj_type}")
 
         parts = obj_name.parts
         if len(parts) > 2:
             raise WrongArgumentError(
-                f"Invalid object name: {obj_name.to_string()}.\n"
-                "Only models support three-part namespaces."
+                f"Invalid object name: {obj_name.to_string()}.\nOnly models support three-part namespaces."
             )
 
         name = parts[-1]
-        where = BinaryOperation(op='=', args=[
-            Identifier('name'),
-            Constant(name)
-        ])
+        where = BinaryOperation(op="=", args=[Identifier("name"), Constant(name)])
 
         if obj_type in project_objects:
             database_name = parts[0] if len(parts) > 1 else database_name
-            where = BinaryOperation(op='and', args=[
-                where,
-                BinaryOperation(op='=', args=[Identifier('project'), Constant(database_name)])
-            ])
+            where = BinaryOperation(
+                op="and", args=[where, BinaryOperation(op="=", args=[Identifier("project"), Constant(database_name)])]
+            )
 
         select_statement = Select(
             targets=[Star()],
-            from_table=Identifier(
-                parts=["information_schema", obj_type]
-            ),
-
+            from_table=Identifier(parts=["information_schema", obj_type]),
             where=where,
         )
         query = SQLQuery(select_statement, session=self.session)
@@ -924,7 +878,9 @@ class ExecuteCommands:
                 # model.?attrs
                 parts = value[:1]
                 attrs = value[1:]
-                model_info = self._get_model_info(Identifier(parts=parts), except_absent=False, database_name=database_name)
+                model_info = self._get_model_info(
+                    Identifier(parts=parts), except_absent=False, database_name=database_name
+                )
 
         if model_info is None:
             raise ExecutorException(f"Model not found: {obj_name}")
@@ -939,20 +895,14 @@ class ExecuteCommands:
             model_info["project_name"],
             model_info["model_record"].name,
             attribute=attrs,
-            version=model_info['model_record'].version
+            version=model_info["model_record"].version,
         )
 
-        return ExecuteAnswer(
-            data=ResultSet.from_df(df, table_name="")
-        )
+        return ExecuteAnswer(data=ResultSet.from_df(df, table_name=""))
 
     def answer_create_kb_index(self, statement, database_name):
         table_name = statement.name.parts[-1]
-        project_name = (
-            statement.name.parts[0]
-            if len(statement.name.parts) > 1
-            else database_name
-        )
+        project_name = statement.name.parts[0] if len(statement.name.parts) > 1 else database_name
         self.session.kb_controller.create_index(table_name=table_name, project_name=project_name)
         return ExecuteAnswer()
 
@@ -994,8 +944,7 @@ class ExecuteCommands:
             shortest_training = None
             for model in models:
                 if (
-                    model.status
-                    in (PREDICTOR_STATUS.GENERATING, PREDICTOR_STATUS.TRAINING)
+                    model.status in (PREDICTOR_STATUS.GENERATING, PREDICTOR_STATUS.TRAINING)
                     and model.training_start_at is not None
                     and model.training_stop_at is None
                 ):
@@ -1003,10 +952,7 @@ class ExecuteCommands:
                     if shortest_training is None or training_time < shortest_training:
                         shortest_training = training_time
 
-            if (
-                shortest_training is not None
-                and shortest_training < datetime.timedelta(hours=1)
-            ):
+            if shortest_training is not None and shortest_training < datetime.timedelta(hours=1):
                 raise ExecutorException(
                     f"Can't start {phase_name} process while any other predictor is in status 'training' or 'generating'"
                 )
@@ -1017,13 +963,9 @@ class ExecuteCommands:
         if statement.query_str is None:
             if model_record.data_integration_ref is not None:
                 if model_record.data_integration_ref["type"] == "integration":
-                    integration = self.session.integration_controller.get_by_id(
-                        model_record.data_integration_ref["id"]
-                    )
+                    integration = self.session.integration_controller.get_by_id(model_record.data_integration_ref["id"])
                     if integration is None:
-                        raise EntityNotExistsError(
-                            "The database from which the model was trained no longer exists"
-                        )
+                        raise EntityNotExistsError("The database from which the model was trained no longer exists")
         elif statement.integration_name is None:
             # set to current project
             statement.integration_name = Identifier(database_name)
@@ -1035,25 +977,19 @@ class ExecuteCommands:
 
             if "engine" in statement.using:
                 ml_integration_name = statement.using.pop("engine")
-                ml_handler = self.session.integration_controller.get_ml_handler(
-                    ml_integration_name
-                )
+                ml_handler = self.session.integration_controller.get_ml_handler(ml_integration_name)
 
         # use current ml handler
         if ml_handler is None:
             integration_record = get_predictor_integration(model_record)
             if integration_record is None:
                 raise EntityNotExistsError("ML engine model was trained with does not esxists")
-            ml_handler = self.session.integration_controller.get_ml_handler(
-                integration_record.name
-            )
+            ml_handler = self.session.integration_controller.get_ml_handler(integration_record.name)
 
         self._sync_predictor_check(phase_name="retrain")
         df = self.session.model_controller.retrain_model(statement, ml_handler)
 
-        return ExecuteAnswer(
-            data=ResultSet.from_df(df)
-        )
+        return ExecuteAnswer(data=ResultSet.from_df(df))
 
     @profiler.profile()
     @mark_process("learn")
@@ -1071,19 +1007,13 @@ class ExecuteCommands:
         # use current ml handler
         integration_record = get_predictor_integration(model_record)
         if integration_record is None:
-            raise Exception(
-                "The ML engine that the model was trained with does not exist."
-            )
-        ml_handler = self.session.integration_controller.get_ml_handler(
-            integration_record.name
-        )
+            raise Exception("The ML engine that the model was trained with does not exist.")
+        ml_handler = self.session.integration_controller.get_ml_handler(integration_record.name)
 
         self._sync_predictor_check(phase_name="finetune")
         df = self.session.model_controller.finetune_model(statement, ml_handler)
 
-        return ExecuteAnswer(
-            data=ResultSet.from_df(df)
-        )
+        return ExecuteAnswer(data=ResultSet.from_df(df))
 
     def _create_integration(self, name: str, engine: str, connection_args: dict):
         # we have connection checkers not for any db. So do nothing if fail
@@ -1100,7 +1030,9 @@ class ExecuteCommands:
                 raise ExecutorException(f"There is no engine '{engine}'")
 
             if handler_meta.get("import", {}).get("success") is not True:
-                raise ExecutorException(f"The '{engine}' handler isn't installed.\n" + get_handler_install_message(engine))
+                raise ExecutorException(
+                    f"The '{engine}' handler isn't installed.\n" + get_handler_install_message(engine)
+                )
 
             accept_connection_args = handler_meta.get("connection_args")
             if accept_connection_args is not None and connection_args is not None:
@@ -1118,25 +1050,17 @@ class ExecuteCommands:
                         if isinstance(arg_value, (str, dict)) is False:
                             raise ExecutorException(f"Unknown type of arg: '{arg_value}'")
                         if isinstance(arg_value, str) or "path" in arg_value:
-                            path = (
-                                arg_value
-                                if isinstance(arg_value, str)
-                                else arg_value["path"]
-                            )
+                            path = arg_value if isinstance(arg_value, str) else arg_value["path"]
                             if Path(path).is_file() is False:
                                 raise ExecutorException(f"File not found at: '{path}'")
                         elif "url" in arg_value:
                             path = download_file(arg_value["url"])
                         else:
-                            raise ExecutorException(
-                                f"Argument '{arg_name}' must be path or url to the file"
-                            )
+                            raise ExecutorException(f"Argument '{arg_name}' must be path or url to the file")
                         connection_args[arg_name] = path
 
             handler = self.session.integration_controller.create_tmp_handler(
-                name=name,
-                engine=engine,
-                connection_args=connection_args
+                name=name, engine=engine, connection_args=connection_args
             )
             status = handler.check_connection()
             if status.copy_storage:
@@ -1149,13 +1073,13 @@ class ExecuteCommands:
 
         integration = self.session.integration_controller.get(name)
         if integration is not None:
-            raise EntityExistsError('Database already exists', name)
+            raise EntityExistsError("Database already exists", name)
         try:
             integration = ProjectController().get(name=name)
         except EntityNotExistsError:
             pass
         if integration is not None:
-            raise EntityExistsError('Project exists with this name', name)
+            raise EntityExistsError("Project exists with this name", name)
 
         self.session.integration_controller.add(name, engine, connection_args)
         if storage:
@@ -1163,11 +1087,10 @@ class ExecuteCommands:
             handler.handler_storage.import_files(storage)
 
     def answer_create_ml_engine(self, name: str, handler: str, params: dict = None, if_not_exists=False):
-
         integrations = self.session.integration_controller.get_all()
         if name in integrations:
             if not if_not_exists:
-                raise EntityExistsError('Integration already exists', name)
+                raise EntityExistsError("Integration already exists", name)
             else:
                 return ExecuteAnswer()
 
@@ -1185,21 +1108,19 @@ class ExecuteCommands:
                 params_out[key] = value
 
         try:
-            self.session.integration_controller.add(
-                name=name, engine=handler, connection_args=params_out
-            )
+            self.session.integration_controller.add(name=name, engine=handler, connection_args=params_out)
         except Exception as e:
             msg = str(e)
             if type(e) in (ImportError, ModuleNotFoundError):
                 msg = dedent(
                     f"""\
-                    The '{handler_module_meta['name']}' handler cannot be used. Reason is:
-                        {handler_module_meta['import']['error_message']}
+                    The '{handler_module_meta["name"]}' handler cannot be used. Reason is:
+                        {handler_module_meta["import"]["error_message"]}
                 """
                 )
                 is_cloud = self.session.config.get("cloud", False)
-                if is_cloud is False and "No module named" in handler_module_meta['import']['error_message']:
-                    logger.info(get_handler_install_message(handler_module_meta['name']))
+                if is_cloud is False and "No module named" in handler_module_meta["import"]["error_message"]:
+                    logger.info(get_handler_install_message(handler_module_meta["name"]))
             ast_drop = DropMLEngine(name=Identifier(name))
             self.answer_drop_ml_engine(ast_drop)
             logger.info(msg)
@@ -1212,7 +1133,7 @@ class ExecuteCommands:
         integrations = self.session.integration_controller.get_all()
         if name not in integrations:
             if not statement.if_exists:
-                raise EntityNotExistsError('Integration does not exists', name)
+                raise EntityNotExistsError("Integration does not exists", name)
             else:
                 return ExecuteAnswer()
         self.session.integration_controller.delete(name)
@@ -1281,25 +1202,15 @@ class ExecuteCommands:
                 # TODO do we need feature: delete object from project via drop table?
 
                 project = self.session.database_controller.get_project(db_name)
-                project_tables = {
-                    key: val
-                    for key, val in project.get_tables().items()
-                    if val.get("deletable") is True
-                }
+                project_tables = {key: val for key, val in project.get_tables().items() if val.get("deletable") is True}
                 table_name = table.to_string()
 
                 if table_name in project_tables:
-                    self.session.model_controller.delete_model(
-                        table_name, project_name=db_name
-                    )
+                    self.session.model_controller.delete_model(table_name, project_name=db_name)
                 elif statement.if_exists is False:
-                    raise ExecutorException(
-                        f"Cannot delete a table from database '{db_name}': table does not exists"
-                    )
+                    raise ExecutorException(f"Cannot delete a table from database '{db_name}': table does not exists")
             else:
-                raise ExecutorException(
-                    f"Cannot delete a table from database '{db_name}'"
-                )
+                raise ExecutorException(f"Cannot delete a table from database '{db_name}'")
 
         return ExecuteAnswer()
 
@@ -1320,9 +1231,7 @@ class ExecuteCommands:
         if isinstance(statement.from_table, Identifier):
             query = Select(
                 targets=[Star()],
-                from_table=NativeQuery(
-                    integration=statement.from_table, query=statement.query_str
-                ),
+                from_table=NativeQuery(integration=statement.from_table, query=statement.query_str),
             )
             query_str = str(query)
         else:
@@ -1332,15 +1241,11 @@ class ExecuteCommands:
             # check create view sql
             query.limit = Constant(1)
 
-            query_context_controller.set_context(
-                query_context_controller.IGNORE_CONTEXT
-            )
+            query_context_controller.set_context(query_context_controller.IGNORE_CONTEXT)
             try:
                 SQLQuery(query, session=self.session, database=database_name)
             finally:
-                query_context_controller.release_context(
-                    query_context_controller.IGNORE_CONTEXT
-                )
+                query_context_controller.release_context(query_context_controller.IGNORE_CONTEXT)
 
         project = self.session.database_controller.get_project(project_name)
         try:
@@ -1370,24 +1275,23 @@ class ExecuteCommands:
         return ExecuteAnswer()
 
     def answer_create_kb(self, statement: CreateKnowledgeBase, database_name: str):
-        project_name = (
-            statement.name.parts[0]
-            if len(statement.name.parts) > 1
-            else database_name
-        )
+        if statement.model:
+            raise ExecutorException(
+                "Creating a knowledge base using pre-existing models is no longer supported.\n"
+                "Please pass the model parameters as a JSON object in the embedding_model field."
+            )
+
+        project_name = statement.name.parts[0] if len(statement.name.parts) > 1 else database_name
 
         if statement.storage is not None:
             if len(statement.storage.parts) != 2:
                 raise ExecutorException(
-                    f"Invalid vectordatabase table name: {statement.storage}"
-                    "Need the form 'database_name.table_name'"
+                    f"Invalid vectordatabase table name: {statement.storage}Need the form 'database_name.table_name'"
                 )
 
         if statement.from_query is not None:
             # TODO: implement this
-            raise ExecutorException(
-                "Create a knowledge base from a select is not supported yet"
-            )
+            raise ExecutorException("Create a knowledge base from a select is not supported yet")
 
         kb_name = statement.name.parts[-1]
 
@@ -1395,7 +1299,7 @@ class ExecuteCommands:
         _ = self.session.kb_controller.add(
             name=kb_name,
             project_name=project_name,
-            embedding_model=statement.model,
+            # embedding_model=statement.model,
             storage=statement.storage,
             params=statement.params,
             if_not_exists=statement.if_not_exists,
@@ -1405,11 +1309,7 @@ class ExecuteCommands:
 
     def answer_drop_kb(self, statement: DropKnowledgeBase, database_name: str):
         name = statement.name.parts[-1]
-        project_name = (
-            statement.name.parts[0]
-            if len(statement.name.parts) > 1
-            else database_name
-        )
+        project_name = statement.name.parts[0] if len(statement.name.parts) > 1 else database_name
 
         # delete the knowledge base
         self.session.kb_controller.delete(
@@ -1422,19 +1322,10 @@ class ExecuteCommands:
 
     def answer_create_skill(self, statement, database_name):
         name = statement.name.parts[-1]
-        project_name = (
-            statement.name.parts[0]
-            if len(statement.name.parts) > 1
-            else database_name
-        )
+        project_name = statement.name.parts[0] if len(statement.name.parts) > 1 else database_name
 
         try:
-            _ = self.session.skills_controller.add_skill(
-                name,
-                project_name,
-                statement.type,
-                statement.params
-            )
+            _ = self.session.skills_controller.add_skill(name, project_name, statement.type, statement.params)
         except ValueError as e:
             # Project does not exist or skill already exists.
             raise ExecutorException(str(e))
@@ -1443,11 +1334,7 @@ class ExecuteCommands:
 
     def answer_drop_skill(self, statement, database_name):
         name = statement.name.parts[-1]
-        project_name = (
-            statement.name.parts[0]
-            if len(statement.name.parts) > 1
-            else database_name
-        )
+        project_name = statement.name.parts[0] if len(statement.name.parts) > 1 else database_name
 
         try:
             self.session.skills_controller.delete_skill(name, project_name)
@@ -1459,19 +1346,12 @@ class ExecuteCommands:
 
     def answer_update_skill(self, statement, database_name):
         name = statement.name.parts[-1]
-        project_name = (
-            statement.name.parts[0]
-            if len(statement.name.parts) > 1
-            else database_name
-        )
+        project_name = statement.name.parts[0] if len(statement.name.parts) > 1 else database_name
 
-        type = statement.params.pop('type', None)
+        type = statement.params.pop("type", None)
         try:
             _ = self.session.skills_controller.update_skill(
-                name,
-                project_name=project_name,
-                type=type,
-                params=statement.params
+                name, project_name=project_name, type=type, params=statement.params
             )
         except ValueError as e:
             # Project does not exist or skill does not exist.
@@ -1481,14 +1361,10 @@ class ExecuteCommands:
 
     def answer_create_agent(self, statement, database_name):
         name = statement.name.parts[-1]
-        project_name = (
-            statement.name.parts[0]
-            if len(statement.name.parts) > 1
-            else database_name
-        )
+        project_name = statement.name.parts[0] if len(statement.name.parts) > 1 else database_name
 
-        skills = statement.params.pop('skills', [])
-        provider = statement.params.pop('provider', None)
+        skills = statement.params.pop("skills", [])
+        provider = statement.params.pop("provider", None)
         try:
             _ = self.session.agents_controller.add_agent(
                 name=name,
@@ -1496,7 +1372,7 @@ class ExecuteCommands:
                 model_name=statement.model,
                 skills=skills,
                 provider=provider,
-                params=statement.params
+                params=statement.params,
             )
         except ValueError as e:
             # Project does not exist or agent already exists.
@@ -1506,11 +1382,7 @@ class ExecuteCommands:
 
     def answer_drop_agent(self, statement, database_name):
         name = statement.name.parts[-1]
-        project_name = (
-            statement.name.parts[0]
-            if len(statement.name.parts) > 1
-            else database_name
-        )
+        project_name = statement.name.parts[0] if len(statement.name.parts) > 1 else database_name
 
         try:
             self.session.agents_controller.delete_agent(name, project_name)
@@ -1522,15 +1394,11 @@ class ExecuteCommands:
 
     def answer_update_agent(self, statement, database_name):
         name = statement.name.parts[-1]
-        project_name = (
-            statement.name.parts[0]
-            if len(statement.name.parts) > 1
-            else database_name
-        )
+        project_name = statement.name.parts[0] if len(statement.name.parts) > 1 else database_name
 
-        model = statement.params.pop('model', None)
-        skills_to_add = statement.params.pop('skills_to_add', [])
-        skills_to_remove = statement.params.pop('skills_to_remove', [])
+        model = statement.params.pop("model", None)
+        skills_to_add = statement.params.pop("skills_to_add", [])
+        skills_to_remove = statement.params.pop("skills_to_remove", [])
         try:
             _ = self.session.agents_controller.update_agent(
                 name,
@@ -1538,7 +1406,7 @@ class ExecuteCommands:
                 model_name=model,
                 skills_to_add=skills_to_add,
                 skills_to_remove=skills_to_remove,
-                params=statement.params
+                params=statement.params,
             )
         except (EntityExistsError, EntityNotExistsError, ValueError) as e:
             # Project does not exist or agent does not exist.
@@ -1568,24 +1436,17 @@ class ExecuteCommands:
             statement.integration_name = Identifier(database_name)
 
         try:
-            ml_handler = self.session.integration_controller.get_ml_handler(
-                ml_integration_name
-            )
+            ml_handler = self.session.integration_controller.get_ml_handler(ml_integration_name)
         except EntityNotExistsError:
             # not exist, try to create it with same name as handler
             self.answer_create_ml_engine(ml_integration_name, handler=ml_integration_name)
 
-            ml_handler = self.session.integration_controller.get_ml_handler(
-                ml_integration_name
-            )
+            ml_handler = self.session.integration_controller.get_ml_handler(ml_integration_name)
 
         if getattr(statement, "is_replace", False) is True:
             # try to delete
             try:
-                self.session.model_controller.delete_model(
-                    model_name,
-                    project_name=integration_name
-                )
+                self.session.model_controller.delete_model(model_name, project_name=integration_name)
             except EntityNotExistsError:
                 pass
 
@@ -1618,9 +1479,7 @@ class ExecuteCommands:
             "and",
             args=[
                 BinaryOperation("=", args=[Identifier("TABLE_SCHEMA"), Constant(db)]),
-                BinaryOperation(
-                    "=", args=[Identifier("TABLE_NAME"), Constant(table_name)]
-                ),
+                BinaryOperation("=", args=[Identifier("TABLE_NAME"), Constant(table_name)]),
             ],
         )
         if where is not None:
@@ -1657,9 +1516,7 @@ class ExecuteCommands:
     def answer_show_create_table(self, table):
         columns = [
             Column(table_name="", name="Table", type=TYPES.MYSQL_TYPE_VAR_STRING),
-            Column(
-                table_name="", name="Create Table", type=TYPES.MYSQL_TYPE_VAR_STRING
-            ),
+            Column(table_name="", name="Create Table", type=TYPES.MYSQL_TYPE_VAR_STRING),
         ]
         return ExecuteAnswer(
             data=ResultSet(
@@ -1987,14 +1844,14 @@ class ExecuteCommands:
 
     def answer_update_model_version(self, model_version, database_name):
         if not isinstance(model_version, Identifier):
-            raise ExecutorException(f'Please define version: {model_version}')
+            raise ExecutorException(f"Please define version: {model_version}")
 
         model_parts = model_version.parts
         version = model_parts[-1]
         if version.isdigit():
             version = int(version)
         else:
-            raise ExecutorException(f'Unknown version: {version}')
+            raise ExecutorException(f"Unknown version: {version}")
 
         if len(model_parts) == 3:
             project_name, model_name = model_parts[:2]
@@ -2002,13 +1859,12 @@ class ExecuteCommands:
             model_name = model_parts[0]
             project_name = database_name
         else:
-            raise ExecutorException(f'Unknown model: {model_version}')
+            raise ExecutorException(f"Unknown model: {model_version}")
 
         self.session.model_controller.set_model_active_version(project_name, model_name, version)
         return ExecuteAnswer()
 
     def answer_drop_model(self, statement, database_name):
-
         model_parts = statement.name.parts
         version = None
 
@@ -2023,7 +1879,7 @@ class ExecuteCommands:
             model_name = model_parts[0]
             project_name = database_name
         else:
-            raise ExecutorException(f'Unknown model: {statement.name}')
+            raise ExecutorException(f"Unknown model: {statement.name}")
 
         if version is not None:
             # delete version