MindsDB 25.3.2.0__py3-none-any.whl → 25.3.4.0__py3-none-any.whl

mindsdb/__about__.py

@@ -1,6 +1,6 @@
 __title__ = 'MindsDB'
 __package_name__ = 'mindsdb'
-__version__ = '25.3.2.0'
+__version__ = '25.3.4.0'
 __description__ = "MindsDB's AI SQL Server enables developers to build AI tools that need access to real-time data to perform their tasks"
 __email__ = "jorge@mindsdb.com"
 __author__ = 'MindsDB Inc'

mindsdb/__main__.py

@@ -46,7 +46,6 @@ try:
 except RuntimeError:
     logger.info('Torch multiprocessing context already set, ignoring...')
 
-
 _stop_event = threading.Event()
 
 

mindsdb/api/executor/datahub/datanodes/information_schema_datanode.py

@@ -3,12 +3,8 @@ import pandas as pd
 from mindsdb_sql_parser.ast.base import ASTNode
 
 from mindsdb.api.executor.datahub.datanodes.datanode import DataNode
-from mindsdb.api.executor.datahub.datanodes.integration_datanode import (
-    IntegrationDataNode,
-)
-from mindsdb.api.executor.datahub.datanodes.project_datanode import (
-    ProjectDataNode,
-)
+from mindsdb.api.executor.datahub.datanodes.integration_datanode import IntegrationDataNode
+from mindsdb.api.executor.datahub.datanodes.project_datanode import ProjectDataNode
 from mindsdb.api.executor import exceptions as exc
 from mindsdb.api.executor.utilities.sql import query_df
 from mindsdb.api.executor.utilities.sql import get_query_tables

mindsdb/api/executor/datahub/datanodes/mindsdb_tables.py

@@ -310,7 +310,7 @@ class ChatbotsTable(MdbTable):
         ):
             project_name = query.where.args[1].value
 
-        chatbot_data = chatbot_controller.get_chatbots(project_name)
+        chatbot_data = chatbot_controller.get_chatbots(project_name=project_name)
 
         columns = cls.columns
         columns_lower = [col.lower() for col in columns]

mindsdb/api/http/namespaces/agents.py

@@ -47,7 +47,7 @@ def create_agent(project_name, name, agent):
 
     try:
         existing_agent = agents_controller.get_agent(name, project_name=project_name)
-    except ValueError:
+    except (ValueError, EntityNotExistsError):
         # Project must exist.
         return http_error(
             HTTPStatus.NOT_FOUND,
@@ -141,7 +141,7 @@ class AgentResource(Resource):
                     f'Agent with name {agent_name} does not exist'
                 )
             return existing_agent.as_dict()
-        except ValueError:
+        except (ValueError, EntityNotExistsError):
             # Project needs to exist.
             return http_error(
                 HTTPStatus.NOT_FOUND,
@@ -173,7 +173,11 @@ class AgentResource(Resource):
                 f'Project with name {project_name} does not exist'
             )
         if existing_agent_record is None:
-            raise Exception
+            return http_error(
+                HTTPStatus.BAD_REQUEST,
+                'Creation is not allowed',
+                'Creation of an agent using the PUT method is not allowed.'
+            )
 
         agent = request.json['agent']
         name = agent.get('name', None)
@@ -272,7 +276,7 @@ class AgentResource(Resource):
                     'Agent not found',
                     f'Agent with name {agent_name} does not exist'
                 )
-        except ValueError:
+        except (ValueError, EntityNotExistsError):
             # Project needs to exist.
             return http_error(
                 HTTPStatus.NOT_FOUND,
@@ -435,7 +439,7 @@ class AgentCompletions(Resource):
                     'Agent not found',
                     f'Agent with name {agent_name} does not exist'
                 )
-        except ValueError:
+        except (ValueError, EntityNotExistsError):
             # Project needs to exist.
             return http_error(
                 HTTPStatus.NOT_FOUND,

mindsdb/api/http/namespaces/chatbots.py

@@ -11,6 +11,7 @@ from mindsdb.metrics.metrics import api_endpoint_metrics
 from mindsdb.interfaces.chatbot.chatbot_controller import ChatBotController
 from mindsdb.interfaces.model.functions import PredictorRecordNotFound
 from mindsdb.interfaces.storage.db import Predictor
+from mindsdb.utilities.exception import EntityNotExistsError
 
 
 def create_chatbot(project_name, name, chatbot):
@@ -59,7 +60,7 @@ def create_chatbot(project_name, name, chatbot):
 
     try:
         existing_chatbot = chatbot_controller.get_chatbot(name, project_name=project_name)
-    except ValueError:
+    except EntityNotExistsError:
         # Project must exist.
         return http_error(
             HTTPStatus.NOT_FOUND,
@@ -152,7 +153,7 @@ class ChatBotsResource(Resource):
         chatbot_controller = ChatBotController()
         try:
             all_bots = chatbot_controller.get_chatbots(project_name)
-        except ValueError:
+        except (ValueError, EntityNotExistsError):
             # Project needs to exist.
             return http_error(
                 HTTPStatus.NOT_FOUND,
@@ -197,7 +198,7 @@ class ChatBotResource(Resource):
                     f'Chatbot with name {chatbot_name} does not exist'
                 )
             return existing_chatbot
-        except ValueError:
+        except (ValueError, EntityNotExistsError):
             # Project needs to exist.
             return http_error(
                 HTTPStatus.NOT_FOUND,
@@ -221,7 +222,7 @@ class ChatBotResource(Resource):
 
         try:
             existing_chatbot = chatbot_controller.get_chatbot(chatbot_name, project_name=project_name)
-        except ValueError:
+        except EntityNotExistsError:
             # Project needs to exist.
             return http_error(
                 HTTPStatus.NOT_FOUND,
@@ -306,7 +307,7 @@ class ChatBotResource(Resource):
                     'Chatbot not found',
                     f'Chatbot with name {chatbot_name} does not exist'
                 )
-        except ValueError:
+        except EntityNotExistsError:
             # Project needs to exist.
             return http_error(
                 HTTPStatus.NOT_FOUND,

mindsdb/api/http/namespaces/databases.py

@@ -1,10 +1,9 @@
-from http import HTTPStatus
-import tempfile
 import time
+import shutil
+import tempfile
+from http import HTTPStatus
 from typing import Dict
 from pathlib import Path
-import shutil
-from sqlalchemy.exc import NoResultFound
 
 from flask import request
 from flask_restx import Resource
@@ -337,7 +336,7 @@ class TablesList(Resource):
                 HTTPStatus.BAD_REQUEST, 'Error',
                 error_message
             )
-        except NoResultFound:
+        except EntityNotExistsError:
             # Only support creating tables from integrations.
             pass
 
@@ -419,7 +418,7 @@ class TableResource(Resource):
                 + f'If you want to delete a model or view, use the projects/{database_name}/models/{table_name} or ' \
                 + f'projects/{database_name}/views/{table_name} endpoints instead.'
             return http_error(HTTPStatus.BAD_REQUEST, 'Error', error_message)
-        except NoResultFound:
+        except EntityNotExistsError:
             # Only support dropping tables from integrations.
             pass
 

mindsdb/api/http/namespaces/skills.py

@@ -7,6 +7,7 @@ from mindsdb.metrics.metrics import api_endpoint_metrics
 from mindsdb.api.http.namespaces.configs.projects import ns_conf
 from mindsdb.api.http.utils import http_error
 from mindsdb.interfaces.skills.skills_controller import SkillsController
+from mindsdb.utilities.exception import EntityNotExistsError
 
 
 def create_skill(project_name, skill):
@@ -52,7 +53,7 @@ class SkillsResource(Resource):
         skills_controller = SkillsController()
         try:
             all_skills = skills_controller.get_skills(project_name)
-        except ValueError:
+        except EntityNotExistsError:
             # Project needs to exist.
             return http_error(
                 HTTPStatus.NOT_FOUND,
@@ -88,7 +89,7 @@ class SkillResource(Resource):
         skills_controller = SkillsController()
         try:
             existing_skill = skills_controller.get_skill(skill_name, project_name)
-        except ValueError:
+        except EntityNotExistsError:
             # Project needs to exist
             return http_error(
                 HTTPStatus.NOT_FOUND,
@@ -120,7 +121,7 @@ class SkillResource(Resource):
 
         try:
             existing_skill = skills_controller.get_skill(skill_name, project_name)
-        except ValueError:
+        except EntityNotExistsError:
             # Project needs to exist
             return http_error(
                 HTTPStatus.NOT_FOUND,
@@ -152,7 +153,7 @@ class SkillResource(Resource):
         skills_controller = SkillsController()
         try:
             existing_skill = skills_controller.get_skill(skill_name, project_name)
-        except ValueError:
+        except EntityNotExistsError:
             # Project needs to exist
             return http_error(
                 HTTPStatus.NOT_FOUND,

mindsdb/api/http/namespaces/views.py

@@ -2,13 +2,12 @@ from http import HTTPStatus
 
 from flask import request
 from flask_restx import Resource
-from sqlalchemy.exc import NoResultFound
-
 
 from mindsdb.api.http.utils import http_error
 from mindsdb.api.http.namespaces.configs.projects import ns_conf
 from mindsdb.api.executor.controllers.session_controller import SessionController
 from mindsdb.metrics.metrics import api_endpoint_metrics
+from mindsdb.utilities.exception import EntityNotExistsError
 
 
 @ns_conf.route('/<project_name>/views')
@@ -20,7 +19,7 @@ class ViewsList(Resource):
         session = SessionController()
         try:
             project = session.database_controller.get_project(project_name)
-        except NoResultFound:
+        except EntityNotExistsError:
             return http_error(
                 HTTPStatus.NOT_FOUND,
                 'Project not found',
@@ -55,7 +54,7 @@ class ViewsList(Resource):
 
         try:
             project = session.database_controller.get_project(project_name)
-        except NoResultFound:
+        except EntityNotExistsError:
             return http_error(HTTPStatus.NOT_FOUND, 'Not found', f'Project name {project_name} does not exist')
 
         if project.get_view(name) is not None:
@@ -82,7 +81,7 @@ class ViewResource(Resource):
         session = SessionController()
         try:
             project = session.database_controller.get_project(project_name)
-        except NoResultFound:
+        except EntityNotExistsError:
             return http_error(HTTPStatus.NOT_FOUND, 'Project not found', f'Project name {project_name} does not exist')
 
         view = project.get_view(view_name)
@@ -106,7 +105,7 @@ class ViewResource(Resource):
         session = SessionController()
         try:
             project = session.database_controller.get_project(project_name)
-        except NoResultFound:
+        except EntityNotExistsError:
             return http_error(HTTPStatus.NOT_FOUND, 'Project not found', f'Project name {project_name} does not exist')
 
         existing_view = project.get_view(view_name)
@@ -143,7 +142,7 @@ class ViewResource(Resource):
         session = SessionController()
         try:
             project = session.database_controller.get_project(project_name)
-        except NoResultFound:
+        except EntityNotExistsError:
             return http_error(HTTPStatus.NOT_FOUND, 'Project not found', f'Project name {project_name} does not exist')
 
         if project.get_view(view_name) is None:

mindsdb/integrations/handlers/chromadb_handler/chromadb_handler.py

@@ -210,6 +210,7 @@ class ChromaDBHandler(VectorStoreHandler):
         chroma_db_conditions = []
         for condition in metadata_conditions:
             metadata_key = condition.column.split(".")[-1]
+
             chroma_db_conditions.append(
                 {
                     metadata_key: {
@@ -310,9 +311,29 @@ class ChromaDBHandler(VectorStoreHandler):
             payload = {column: payload[column] for column in columns}
 
         # always include distance
+        distance_filter = None
+        distance_col = TableField.DISTANCE.value
         if distances is not None:
-            payload[TableField.DISTANCE.value] = distances
-        return pd.DataFrame(payload)
+            payload[distance_col] = distances
+
+            for cond in conditions:
+                if cond.column == distance_col:
+                    distance_filter = cond
+                    break
+
+        df = pd.DataFrame(payload)
+        if distance_filter is not None:
+            op_map = {
+                '<': '__lt__',
+                '<=': '__le__',
+                '>': '__gt__',
+                '>=': '__ge__',
+                '=': '__eq__',
+            }
+            op = op_map.get(distance_filter.op.value)
+            if op:
+                df = df[getattr(df[distance_col], op)(distance_filter.value)]
+        return df
 
     def _dataframe_metadata_to_chroma_metadata(self, metadata: Union[Dict[str, str], str]) -> Optional[Dict[str, str]]:
         """Convert DataFrame metadata to ChromaDB compatible metadata format"""

mindsdb/integrations/handlers/dummy_data_handler/dummy_data_handler.py

@@ -1,4 +1,5 @@
 import time
+from typing import Optional, List
 
 import duckdb
 from typing import Any
@@ -36,18 +37,27 @@ class DummyHandler(DatabaseHandler):
         """
         return HandlerStatusResponse(success=True)
 
-    def native_query(self, query: Any) -> HandlerResponse:
+    def native_query(self, query: Any, params: Optional[List] = None) -> HandlerResponse:
         """Receive raw query and act upon it somehow
 
         Args:
-            query (Any): query in native format (str for sql databases,
-                dict for mongo, etc)
+            query (Any): query in native format (str for sql databases, dict for mongo, etc)
+            params (Optional[List])
 
         Returns:
             HandlerResponse
         """
         con = duckdb.connect(self.db_path)
-        result_df = con.execute(query).fetchdf()
+        if params is not None:
+            query = query.replace('%s', '?')
+            cur = con.executemany(query, params)
+            if cur.rowcount >= 0:
+                result_df = cur.fetchdf()
+            else:
+                con.close()
+                return HandlerResponse(RESPONSE_TYPE.OK)
+        else:
+            result_df = con.execute(query).fetchdf()
         con.close()
         return HandlerResponse(RESPONSE_TYPE.TABLE, result_df)
 
@@ -62,8 +72,8 @@ class DummyHandler(DatabaseHandler):
             HandlerResponse
         """
         renderer = SqlalchemyRender('postgres')
-        query_str = renderer.get_string(query, with_failback=True)
-        return self.native_query(query_str)
+        query_str, params = renderer.get_exec_params(query, with_failback=True)
+        return self.native_query(query_str, params)
 
     def get_tables(self) -> HandlerResponse:
         """Get a list of all the tables in the database

mindsdb/integrations/handlers/file_handler/tests/test_file_handler.py

@@ -8,7 +8,6 @@ import pandas
 import pytest
 from mindsdb_sql_parser.exceptions import ParsingException
 from mindsdb_sql_parser.ast import CreateTable, DropTables, Identifier, Insert, TableColumn, Update
-from pytest_lazyfixture import lazy_fixture
 
 from mindsdb.integrations.handlers.file_handler.file_handler import FileHandler
 from mindsdb.integrations.libs.response import RESPONSE_TYPE
@@ -75,33 +74,26 @@ def curr_dir():
     return os.path.dirname(os.path.realpath(__file__))
 
 
-# Fixtures to get a path to a partiular type of file
-@pytest.fixture
 def csv_file() -> str:
     return os.path.join(curr_dir(), "data", "test.csv")
 
 
-@pytest.fixture
 def xlsx_file() -> str:
     return os.path.join(curr_dir(), "data", "test.xlsx")
 
 
-@pytest.fixture
 def json_file() -> str:
     return os.path.join(curr_dir(), "data", "test.json")
 
 
-@pytest.fixture
 def parquet_file() -> str:
     return os.path.join(curr_dir(), "data", "test.parquet")
 
 
-@pytest.fixture
 def pdf_file() -> str:
     return os.path.join(curr_dir(), "data", "test.pdf")
 
 
-@pytest.fixture
 def txt_file() -> str:
     return os.path.join(curr_dir(), "data", "test.txt")
 
@@ -109,56 +101,47 @@ def txt_file() -> str:
 class TestIsItX:
     """Tests all of the 'is_it_x()' functions to determine a file's type"""
 
-    # We can't test xlsx or parquet here because they're binary files
-    @pytest.mark.parametrize(
-        "file_path,result",
-        [(lazy_fixture("csv_file"), True), (lazy_fixture("json_file"), False)],
-    )
-    def test_is_it_csv(self, file_path, result):
-        with open(file_path, "r") as fh:
-            assert FileReader.is_csv(StringIO(fh.read())) is result
-
-    @pytest.mark.parametrize(
-        "file_path,result",
-        [
-            (lazy_fixture("csv_file"), 'csv'),
-            (lazy_fixture("xlsx_file"), 'xlsx'),
-            (lazy_fixture("json_file"), 'json'),
-            (lazy_fixture("parquet_file"), 'parquet'),
-            (lazy_fixture("txt_file"), 'txt'),
-            (lazy_fixture("pdf_file"), 'pdf'),
-        ],
-    )
-    def test_format(self, file_path, result):
-        assert FileReader(path=file_path).get_format() == result
-
-    # We can't test xlsx or parquet here because they're binary files
-    @pytest.mark.parametrize(
-        "file_path,result",
-        [
-            (lazy_fixture("csv_file"), False),
-            (lazy_fixture("json_file"), True),
-            (lazy_fixture("txt_file"), False),
-        ],
-    )
-    def test_is_it_json(self, file_path, result):
-        with open(file_path, "r") as fh:
-            assert FileReader.is_json(StringIO(fh.read())) is result
-
-    @pytest.mark.parametrize(
-        "file_path,result",
-        [
-            (lazy_fixture("csv_file"), False),
-            (lazy_fixture("xlsx_file"), False),
-            (lazy_fixture("json_file"), False),
-            (lazy_fixture("parquet_file"), True),
-            (lazy_fixture("txt_file"), False),
-            (lazy_fixture("pdf_file"), False),
-        ],
-    )
-    def test_is_it_parquet(self, file_path, result):
-        with open(file_path, "rb") as fh:
-            assert FileReader.is_parquet(BytesIO(fh.read())) is result
+    def test_is_it_csv(self):
+        # We can't test xlsx or parquet here because they're binary files
+        for file_path, result in (
+            (csv_file(), True),
+            (json_file(), False)
+        ):
+            with open(file_path, "r") as fh:
+                assert FileReader.is_csv(StringIO(fh.read())) is result
+
+    def test_format(self):
+        for file_path, result in (
+            (csv_file(), 'csv'),
+            (xlsx_file(), 'xlsx'),
+            (json_file(), 'json'),
+            (parquet_file(), 'parquet'),
+            (txt_file(), 'txt'),
+            (pdf_file(), 'pdf'),
+        ):
+            assert FileReader(path=file_path).get_format() == result
+
+    def test_is_it_json(self):
+        # We can't test xlsx or parquet here because they're binary files
+        for file_path, result in (
+            (csv_file(), False),
+            (json_file(), True),
+            (txt_file(), False),
+        ):
+            with open(file_path, "r") as fh:
+                assert FileReader.is_json(StringIO(fh.read())) is result
+
+    def test_is_it_parquet(self):
+        for file_path, result in (
+            (csv_file(), False),
+            (xlsx_file(), False),
+            (json_file(), False),
+            (parquet_file(), True),
+            (txt_file(), False),
+            (pdf_file(), False),
+        ):
+            with open(file_path, "rb") as fh:
+                assert FileReader.is_parquet(BytesIO(fh.read())) is result
 
 
 class TestQuery:
@@ -188,13 +171,14 @@ class TestQuery:
 
         assert response.type == RESPONSE_TYPE.ERROR
 
-    def test_query_insert(self, csv_file, monkeypatch):
+    def test_query_insert(self, monkeypatch):
         """Test an invalid insert query"""
         # Create a temporary file to save the csv file to.
+        csv_file_path = csv_file()
         csv_tmp = os.path.join(tempfile.gettempdir(), "test.csv")
         if os.path.exists(csv_tmp):
             os.remove(csv_tmp)
-        shutil.copy(csv_file, csv_tmp)
+        shutil.copy(csv_file_path, csv_tmp)
 
         def mock_get_file_path(self, name):
             return csv_tmp
@@ -270,18 +254,7 @@ class TestQuery:
             file_handler.native_query("INVALID QUERY")
 
 
-@pytest.mark.parametrize(
-    "file_path,expected_columns",
-    [
-        (lazy_fixture("csv_file"), test_file_content[0]),
-        (lazy_fixture("xlsx_file"), test_file_content[0]),
-        (lazy_fixture("json_file"), test_file_content[0]),
-        (lazy_fixture("parquet_file"), test_file_content[0]),
-        (lazy_fixture("pdf_file"), ["content", "metadata"]),
-        (lazy_fixture("txt_file"), ["content", "metadata"]),
-    ],
-)
-def test_handle_source(file_path, expected_columns):
+def test_handle_source():
 
     def get_reader(file_path):
         # using path
@@ -300,17 +273,25 @@ def test_handle_source(file_path, expected_columns):
         reader = FileReader(file=fd, name=Path(file_path).name)
         yield reader
 
-    # using different methods to create reader
-    for reader in get_reader(file_path):
-        df = reader.get_page_content()
-        assert isinstance(df, pandas.DataFrame)
-
-        assert df.columns.tolist() == expected_columns
-
-        # The pdf and txt files have some different content
-        if reader.get_format() not in ("pdf", "txt"):
-            assert len(df) == len(test_file_content) - 1
-            assert df.values.tolist() == test_file_content[1:]
+    for file_path, expected_columns in (
+        (csv_file(), test_file_content[0]),
+        (xlsx_file(), test_file_content[0]),
+        (json_file(), test_file_content[0]),
+        (parquet_file(), test_file_content[0]),
+        (pdf_file(), ["content", "metadata"]),
+        (txt_file(), ["content", "metadata"]),
+    ):
+        # using different methods to create reader
+        for reader in get_reader(file_path):
+            df = reader.get_page_content()
+            assert isinstance(df, pandas.DataFrame)
+
+            assert df.columns.tolist() == expected_columns
+
+            # The pdf and txt files have some different content
+            if reader.get_format() not in ("pdf", "txt"):
+                assert len(df) == len(test_file_content) - 1
+                assert df.values.tolist() == test_file_content[1:]
 
 
 @pytest.mark.parametrize(