MindsDB 25.5.4.1__py3-none-any.whl → 25.6.2.0__py3-none-any.whl

mindsdb/interfaces/file/file_controller.py

@@ -26,17 +26,10 @@ class FileController:
 
     def get_files_names(self):
         """return list of files names"""
-        return [
-            x[0]
-            for x in db.session.query(db.File.name).filter_by(company_id=ctx.company_id)
-        ]
+        return [x[0] for x in db.session.query(db.File.name).filter_by(company_id=ctx.company_id)]
 
     def get_file_meta(self, name):
-        file_record = (
-            db.session.query(db.File)
-            .filter_by(company_id=ctx.company_id, name=name)
-            .first()
-        )
+        file_record = db.session.query(db.File).filter_by(company_id=ctx.company_id, name=name).first()
         if file_record is None:
             return None
         columns = file_record.columns
@@ -54,9 +47,7 @@ class FileController:
         Returns:
             list[dict]: files metadata
         """
-        file_records = (
-            db.session.query(db.File).filter_by(company_id=ctx.company_id).all()
-        )
+        file_records = db.session.query(db.File).filter_by(company_id=ctx.company_id).all()
         files_metadata = [
             {
                 "name": record.name,
@@ -89,10 +80,7 @@ class FileController:
         try:
             pages_files, pages_index = self.get_file_pages(file_path)
 
-            metadata = {
-                'is_feather': True,
-                'pages': pages_index
-            }
+            metadata = {"is_feather": True, "pages": pages_index}
             df = pages_files[0]
             file_record = db.File(
                 name=name,
@@ -101,7 +89,7 @@ class FileController:
                 file_path="",
                 row_count=len(df),
                 columns=list(df.columns),
-                metadata_=metadata
+                metadata_=metadata,
             )
             db.session.add(file_record)
             db.session.flush()
@@ -157,15 +145,11 @@ class FileController:
         """
 
         for num, df in pages_files.items():
-            dest = dest_dir.joinpath(f'{num}.feather')
+            dest = dest_dir.joinpath(f"{num}.feather")
             df.to_feather(str(dest))
 
     def delete_file(self, name):
-        file_record = (
-            db.session.query(db.File)
-            .filter_by(company_id=ctx.company_id, name=name)
-            .first()
-        )
+        file_record = db.session.query(db.File).filter_by(company_id=ctx.company_id, name=name).first()
         if file_record is None:
             return None
         file_id = file_record.id
@@ -175,20 +159,12 @@ class FileController:
         return True
 
     def get_file_path(self, name):
-        file_record = (
-            db.session.query(db.File)
-            .filter_by(company_id=ctx.company_id, name=name)
-            .first()
-        )
+        file_record = db.session.query(db.File).filter_by(company_id=ctx.company_id, name=name).first()
         if file_record is None:
             raise Exception(f"File '{name}' does not exists")
         file_dir = f"file_{ctx.company_id}_{file_record.id}"
         self.fs_store.get(file_dir, base_dir=self.dir)
-        return str(
-            Path(self.dir)
-            .joinpath(file_dir)
-            .joinpath(Path(file_record.source_file_path).name)
-        )
+        return str(Path(self.dir).joinpath(file_dir).joinpath(Path(file_record.source_file_path).name))
 
     def get_file_data(self, name: str, page_name: str = None) -> pd.DataFrame:
         """
@@ -198,11 +174,7 @@ class FileController:
         :param page_name: page name, optional
         :return: Page or file content
         """
-        file_record = (
-            db.session.query(db.File)
-            .filter_by(company_id=ctx.company_id, name=name)
-            .first()
-        )
+        file_record = db.session.query(db.File).filter_by(company_id=ctx.company_id, name=name).first()
         if file_record is None:
             raise Exception(f"File '{name}' does not exists")
 
@@ -210,37 +182,29 @@ class FileController:
         self.fs_store.get(file_dir, base_dir=self.dir)
 
         metadata = file_record.metadata_ or {}
-        if metadata.get('is_feather') is not True:
+        if metadata.get("is_feather") is not True:
             # migrate file
 
-            file_path = (
-                Path(self.dir)
-                .joinpath(file_dir)
-                .joinpath(Path(file_record.source_file_path).name)
-            )
+            file_path = Path(self.dir).joinpath(file_dir).joinpath(Path(file_record.source_file_path).name)
 
             pages_files, pages_index = self.get_file_pages(str(file_path))
 
             self.store_pages_as_feather(file_path.parent, pages_files)
-            metadata['is_feather'] = True
-            metadata['pages'] = pages_index
+            metadata["is_feather"] = True
+            metadata["pages"] = pages_index
 
             file_record.metadata_ = metadata
-            flag_modified(file_record, 'metadata_')
+            flag_modified(file_record, "metadata_")
             db.session.commit()
 
         if page_name is None:
             num = 0
         else:
-            num = metadata.get('pages', {}).get(page_name)
+            num = metadata.get("pages", {}).get(page_name)
             if num is None:
-                raise KeyError(f'Page not found: {page_name}')
+                raise KeyError(f"Page not found: {page_name}")
 
-        path = (
-            Path(self.dir)
-            .joinpath(file_dir)
-            .joinpath(f'{num}.feather')
-        )
+        path = Path(self.dir).joinpath(file_dir).joinpath(f"{num}.feather")
         return pd.read_feather(path)
 
     def set_file_data(self, name: str, df: pd.DataFrame, page_name: str = None):
@@ -251,11 +215,7 @@ class FileController:
         :param page_name: name of page, optional
         """
 
-        file_record = (
-            db.session.query(db.File)
-            .filter_by(company_id=ctx.company_id, name=name)
-            .first()
-        )
+        file_record = db.session.query(db.File).filter_by(company_id=ctx.company_id, name=name).first()
         if file_record is None:
             raise Exception(f"File '{name}' does not exists")
 
@@ -264,12 +224,8 @@ class FileController:
 
         num = 0
         if page_name is not None and file_record.metadata_ is not None:
-            num = file_record.metadata_.get('pages', {}).get(page_name, 0)
+            num = file_record.metadata_.get("pages", {}).get(page_name, 0)
 
-        path = (
-            Path(self.dir)
-            .joinpath(file_dir)
-            .joinpath(f'{num}.feather')
-        )
+        path = Path(self.dir).joinpath(file_dir).joinpath(f"{num}.feather")
         df.to_feather(path)
         self.fs_store.put(file_dir, base_dir=self.dir)

mindsdb/interfaces/knowledge_base/controller.py

@@ -1,6 +1,8 @@
 import os
 import copy
 from typing import Dict, List, Optional
+import json
+import decimal
 
 import pandas as pd
 import numpy as np
@@ -29,6 +31,7 @@ from mindsdb.interfaces.database.projects import ProjectController
 from mindsdb.interfaces.variables.variables_controller import variables_controller
 from mindsdb.interfaces.knowledge_base.preprocessing.models import PreprocessingConfig, Document
 from mindsdb.interfaces.knowledge_base.preprocessing.document_preprocessor import PreprocessorFactory
+from mindsdb.interfaces.knowledge_base.evaluate import EvaluateBase
 from mindsdb.interfaces.model.functions import PredictorRecordNotFound
 from mindsdb.utilities.exception import EntityExistsError, EntityNotExistsError
 from mindsdb.integrations.utilities.sql_utils import FilterCondition, FilterOperator
@@ -108,6 +111,15 @@ def safe_pandas_is_datetime(value: str) -> bool:
         return False
 
 
+def to_json(obj):
+    if obj is None:
+        return None
+    try:
+        return json.dumps(obj)
+    except TypeError:
+        return obj
+
+
 class KnowledgeBaseTable:
     """
     Knowledge base table interface
@@ -175,10 +187,11 @@ class KnowledgeBaseTable:
         conditions = []
         query_text = None
         relevance_threshold = None
+        reranking_enabled_flag = True
         query_conditions = db_handler.extract_conditions(query.where)
         if query_conditions is not None:
             for item in query_conditions:
-                if item.column == "relevance_threshold" and item.op.value == "=":
+                if item.column == "relevance" and item.op.value == FilterOperator.GREATER_THAN_OR_EQUAL.value:
                     try:
                         relevance_threshold = float(item.value)
                         # Validate range: must be between 0 and 1
@@ -189,6 +202,15 @@ class KnowledgeBaseTable:
                         error_msg = f"Invalid relevance_threshold value: {item.value}. {str(e)}"
                         logger.error(error_msg)
                         raise ValueError(error_msg)
+                elif item.column == "reranking":
+                    reranking_enabled_flag = item.value
+                    # cast to boolean
+                    if isinstance(reranking_enabled_flag, str):
+                        reranking_enabled_flag = reranking_enabled_flag.lower() not in ("false")
+                elif item.column == "relevance" and item.op.value != FilterOperator.GREATER_THAN_OR_EQUAL.value:
+                    raise ValueError(
+                        f"Invalid operator for relevance: {item.op.value}. Only GREATER_THAN_OR_EQUAL is allowed."
+                    )
                 elif item.column == TableField.CONTENT.value:
                     query_text = item.value
 
@@ -222,8 +244,7 @@ class KnowledgeBaseTable:
         logger.debug(f"Query returned {len(df)} rows")
         logger.debug(f"Columns in response: {df.columns.tolist()}")
         # Check if we have a rerank_model configured in KB params
-
-        df = self.add_relevance(df, query_text, relevance_threshold)
+        df = self.add_relevance(df, query_text, relevance_threshold, reranking_enabled_flag)
 
         if (
             query.group_by is not None
@@ -234,15 +255,22 @@ class KnowledgeBaseTable:
             or not isinstance(query.targets[0], Star)
         ):
             query_copy.where = None
+            if "metadata" in df.columns:
+                df["metadata"] = df["metadata"].apply(to_json)
+
             df = query_df(df, query_copy, session=self.session)
 
         return df
 
-    def add_relevance(self, df, query_text, relevance_threshold=None):
+    def score_documents(self, query_text, documents, reranking_model_params):
+        reranker = get_reranking_model_from_params(reranking_model_params)
+        return reranker.get_scores(query_text, documents)
+
+    def add_relevance(self, df, query_text, relevance_threshold=None, reranking_enabled_flag=True):
         relevance_column = TableField.RELEVANCE.value
 
         reranking_model_params = get_model_params(self._kb.params.get("reranking_model"), "default_reranking_model")
-        if reranking_model_params and query_text and len(df) > 0:
+        if reranking_model_params and query_text and len(df) > 0 and reranking_enabled_flag:
             # Use reranker for relevance score
             try:
                 logger.info(f"Using knowledge reranking model from params: {reranking_model_params}")
@@ -601,14 +629,15 @@ class KnowledgeBaseTable:
                 metadata = {}
                 for col in metadata_columns:
                     value = row[col]
+                    value_type = type(value)
                     # Convert numpy/pandas types to Python native types
                     if safe_pandas_is_datetime(value) or isinstance(value, pd.Timestamp):
                         value = str(value)
-                    elif pd.api.types.is_integer_dtype(value):
+                    elif pd.api.types.is_integer_dtype(value_type):
                         value = int(value)
-                    elif pd.api.types.is_float_dtype(value):
+                    elif pd.api.types.is_float_dtype(value_type) or isinstance(value, decimal.Decimal):
                         value = float(value)
-                    elif pd.api.types.is_bool_dtype(value):
+                    elif pd.api.types.is_bool_dtype(value_type):
                         value = bool(value)
                     elif isinstance(value, dict):
                         metadata.update(value)
@@ -935,7 +964,16 @@ class KnowledgeBaseController:
             model_record = db.Predictor.query.get(model["id"])
             embedding_model_id = model_record.id
 
-        reranking_model_params = get_model_params(params.get("reranking_model", {}), "default_reranking_model")
+        # if params.get("reranking_model", {}) is bool and False we evaluate it to empty dictionary
+        reranking_model_params = params.get("reranking_model", {})
+
+        if isinstance(reranking_model_params, bool) and not reranking_model_params:
+            params["reranking_model"] = {}
+        # if params.get("reranking_model", {}) is string and false in any case we evaluate it to empty dictionary
+        if isinstance(reranking_model_params, str) and reranking_model_params.lower() == "false":
+            params["reranking_model"] = {}
+
+        reranking_model_params = get_model_params(reranking_model_params, "default_reranking_model")
         if reranking_model_params:
             # Get reranking model from params.
             # This is called here to check validaity of the parameters.
@@ -1028,7 +1066,7 @@ class KnowledgeBaseController:
         except PredictorRecordNotFound:
             pass
 
-        if params.get("provider", None) not in ("openai", "azure"):
+        if params.get("provider", None) not in ("openai", "azure_openai"):
             # try use litellm
             KnowledgeBaseTable.call_litellm_embedding(self.session, params, ["test"])
             return
@@ -1192,3 +1230,18 @@ class KnowledgeBaseController:
         Update a knowledge base record
         """
         raise NotImplementedError()
+
+    def evaluate(self, table_name: str, project_name: str, params: dict = None) -> pd.DataFrame:
+        """
+        Run evaluate and/or create test data for evaluation
+        :param table_name: name of KB
+        :param project_name: project of KB
+        :param params: evaluation parameters
+        :return: evaluation results
+        """
+        project_id = self.session.database_controller.get_project(project_name).id
+        kb_table = self.get_table(table_name, project_id)
+
+        scores = EvaluateBase.run(self.session, kb_table, params)
+
+        return scores