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

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

@@ -7,12 +7,22 @@ from pathlib import Path
 import pandas
 import pytest
 from mindsdb_sql_parser.exceptions import ParsingException
-from mindsdb_sql_parser.ast import CreateTable, DropTables, Identifier, Insert, TableColumn, Update
+from mindsdb_sql_parser.ast import (
+    CreateTable,
+    DropTables,
+    Identifier,
+    Insert,
+    TableColumn,
+    Update,
+)
 
 from mindsdb.integrations.handlers.file_handler.file_handler import FileHandler
 from mindsdb.integrations.libs.response import RESPONSE_TYPE
 
-from mindsdb.integrations.utilities.files.file_reader import FileReader
+from mindsdb.integrations.utilities.files.file_reader import (
+    FileReader,
+    FileProcessingError,
+)
 
 
 # Define a table to use as content for all of the file types
@@ -103,21 +113,18 @@ class TestIsItX:
 
     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)
-        ):
+        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'),
+            (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
 
@@ -182,6 +189,7 @@ class TestQuery:
 
         def mock_get_file_path(self, name):
             return csv_tmp
+
         monkeypatch.setattr(MockFileController, "get_file_path", mock_get_file_path)
 
         file_handler = FileHandler(file_controller=MockFileController())
@@ -255,14 +263,13 @@ class TestQuery:
 
 
 def test_handle_source():
-
     def get_reader(file_path):
         # using path
         reader = FileReader(path=file_path)
         yield reader
 
         # using file descriptor
-        with open(file_path, 'rb') as fd:
+        with open(file_path, "rb") as fd:
             reader = FileReader(file=fd)
             yield reader
             fd.seek(0)
@@ -310,14 +317,31 @@ def test_check_valid_dialects(csv_string, delimiter):
 def test_tsv():
     file = BytesIO(b"example;csv;file\tname")
 
-    reader = FileReader(file=file, name='test.tsv')
-    assert reader.get_format() == 'csv'
-    assert reader.parameters['delimiter'] == '\t'
+    reader = FileReader(file=file, name="test.tsv")
+    assert reader.get_format() == "csv"
+    assert reader.parameters["delimiter"] == "\t"
 
     df = reader.get_page_content()
     assert len(df.columns) == 2
 
 
+def test_bad_csv_header():
+    file = BytesIO(b" a,b  ,c\n1,2,3\n")
+    reader = FileReader(file=file, name="test.tsv")
+    df = reader.get_page_content()
+    assert set(df.columns) == set(["a", "b", "c"])
+
+    wrong_data = [
+        b"a, ,c\n1,2,3\n",
+        b"a,  \t,c\n1,2,3\n",
+        b"   ,b,c\n1,2,3\n",
+    ]
+    for data in wrong_data:
+        reader = FileReader(file=BytesIO(data), name="test.tsv")
+        with pytest.raises(FileProcessingError):
+            df = reader.get_page_content()
+
+
 def test_check_invalid_dialects():
     with pytest.raises(Exception):
         FileHandler._get_csv_dialect("example csv file")
@@ -334,10 +358,7 @@ def test_get_tables():
     assert response.type == RESPONSE_TYPE.TABLE
 
     expected_df = pandas.DataFrame(
-        [
-            {"TABLE_NAME": x[0], "TABLE_ROWS": x[1], "TABLE_TYPE": "BASE TABLE"}
-            for x in file_records
-        ]
+        [{"TABLE_NAME": x[0], "TABLE_ROWS": x[1], "TABLE_TYPE": "BASE TABLE"} for x in file_records]
     )
 
     assert response.data_frame.equals(expected_df)
@@ -349,8 +370,6 @@ def test_get_columns():
 
     assert response.type == RESPONSE_TYPE.TABLE
 
-    expected_df = pandas.DataFrame(
-        [{"Field": x, "Type": "str"} for x in file_records[0][2]]
-    )
+    expected_df = pandas.DataFrame([{"Field": x, "Type": "str"} for x in file_records[0][2]])
 
     assert response.data_frame.equals(expected_df)

mindsdb/integrations/handlers/litellm_handler/litellm_handler.py

@@ -2,7 +2,7 @@ import ast
 from typing import Dict, Optional, List
 
 
-from litellm import completion, batch_completion, embedding
+from litellm import completion, batch_completion, embedding, acompletion
 import pandas as pd
 
 from mindsdb.integrations.libs.base import BaseMLEngine
@@ -42,10 +42,17 @@ class LiteLLMHandler(BaseMLEngine):
                 f"https://{args['snowflake_account_id']}.snowflakecomputing.com/api/v2/cortex/inference:complete"
             )
 
-        from litellm import acompletion
-
         return await acompletion(model=model, messages=messages, stream=False, **args)
 
+    @staticmethod
+    def completion(model: str, messages: List[dict], args: dict):
+        if model.startswith("snowflake/") and "snowflake_account_id" in args:
+            args["api_base"] = (
+                f"https://{args['snowflake_account_id']}.snowflakecomputing.com/api/v2/cortex/inference:complete"
+            )
+
+        return completion(model=model, messages=messages, stream=False, **args)
+
     def create(
         self,
         target: str,

mindsdb/integrations/handlers/llama_index_handler/requirements.txt

@@ -1,4 +1,4 @@
-llama-index==0.12.21
+llama-index==0.12.28
 pydantic-settings >= 2.1.0
 llama-index-readers-web
 llama-index-embeddings-openai

mindsdb/integrations/handlers/mysql_handler/mysql_handler.py

@@ -31,9 +31,7 @@ def _map_type(mysql_type_text: str) -> MYSQL_DATA_TYPE:
     try:
         return MYSQL_DATA_TYPE(mysql_type_text.upper())
     except Exception:
-        logger.warning(
-            f"MySQL handler: unknown type: {mysql_type_text}, use TEXT as fallback."
-        )
+        logger.warning(f"MySQL handler: unknown type: {mysql_type_text}, use TEXT as fallback.")
         return MYSQL_DATA_TYPE.TEXT
 
 
@@ -65,22 +63,23 @@ def _make_table_response(result: list[dict], cursor: mysql.connector.cursor.MySQ
             mysql_types.append(reverse_c_type_map[type_int])
             continue
 
-        if type_int != C_TYPES.MYSQL_TYPE_BLOB:
-            raise ValueError(f'Unknown MySQL type id={type_int} in column {col[0]}')
-
-        # region determine text/blob type by flags
-        # Unfortunately, there is no way to determine particular type of text/blob column by flags.
-        # Subtype have to be determined by 8-s element of description tuple, but mysql.conector
-        # return the same value for all text types (TINYTEXT, TEXT, MEDIUMTEXT, LONGTEXT), and for
-        # all blob types (TINYBLOB, BLOB, MEDIUMBLOB, LONGBLOB).
-        if col[7] == 16:  # and col[8] == 45
-            mysql_types.append(MYSQL_DATA_TYPE.TEXT)
-        elif col[7] == 144:  # and col[8] == 63
-            mysql_types.append(MYSQL_DATA_TYPE.BLOB)
+        if type_int == C_TYPES.MYSQL_TYPE_BLOB:
+            # region determine text/blob type by flags
+            # Unfortunately, there is no way to determine particular type of text/blob column by flags.
+            # Subtype have to be determined by 8-s element of description tuple, but mysql.conector
+            # return the same value for all text types (TINYTEXT, TEXT, MEDIUMTEXT, LONGTEXT), and for
+            # all blob types (TINYBLOB, BLOB, MEDIUMBLOB, LONGBLOB).
+            if col[7] == 16:  # and col[8] == 45
+                mysql_types.append(MYSQL_DATA_TYPE.TEXT)
+            elif col[7] == 144:  # and col[8] == 63
+                mysql_types.append(MYSQL_DATA_TYPE.BLOB)
+            else:
+                logger.debug(f"MySQL handler: unknown type code {col[7]}, use TEXT as fallback.")
+                mysql_types.append(MYSQL_DATA_TYPE.TEXT)
+            # endregion
         else:
-            logger.debug(f'MySQL handler: unknown type code {col[7]}, use TEXT as fallback.')
+            logger.warning(f"MySQL handler: unknown type id={type_int} in column {col[0]}, use TEXT as fallback.")
             mysql_types.append(MYSQL_DATA_TYPE.TEXT)
-        # endregion
 
     # region cast int and bool to nullable types
     serieses = []
@@ -88,22 +87,20 @@ def _make_table_response(result: list[dict], cursor: mysql.connector.cursor.MySQ
         expected_dtype = None
         column_name = description[i][0]
         if mysql_type in (
-            MYSQL_DATA_TYPE.SMALLINT, MYSQL_DATA_TYPE.INT, MYSQL_DATA_TYPE.MEDIUMINT,
-            MYSQL_DATA_TYPE.BIGINT, MYSQL_DATA_TYPE.TINYINT
+            MYSQL_DATA_TYPE.SMALLINT,
+            MYSQL_DATA_TYPE.INT,
+            MYSQL_DATA_TYPE.MEDIUMINT,
+            MYSQL_DATA_TYPE.BIGINT,
+            MYSQL_DATA_TYPE.TINYINT,
         ):
-            expected_dtype = 'Int64'
+            expected_dtype = "Int64"
         elif mysql_type in (MYSQL_DATA_TYPE.BOOL, MYSQL_DATA_TYPE.BOOLEAN):
-            expected_dtype = 'boolean'
+            expected_dtype = "boolean"
         serieses.append(pd.Series([row[column_name] for row in result], dtype=expected_dtype, name=description[i][0]))
     df = pd.concat(serieses, axis=1, copy=False)
     # endregion
 
-    response = Response(
-        RESPONSE_TYPE.TABLE,
-        df,
-        affected_rows=cursor.rowcount,
-        mysql_types=mysql_types
-    )
+    response = Response(RESPONSE_TYPE.TABLE, df, affected_rows=cursor.rowcount, mysql_types=mysql_types)
     return response
 
 
@@ -182,6 +179,9 @@ class MySQLHandler(DatabaseHandler):
                 config["ssl_cert"] = ssl_cert
             if ssl_key is not None:
                 config["ssl_key"] = ssl_key
+        elif ssl is False:
+            config["ssl_disabled"] = True
+
         if "collation" not in config:
             config["collation"] = "utf8mb4_general_ci"
         if "use_pure" not in config:
@@ -219,9 +219,7 @@ class MySQLHandler(DatabaseHandler):
             connection = self.connect()
             result.success = connection.is_connected()
         except mysql.connector.Error as e:
-            logger.error(
-                f'Error connecting to MySQL {self.connection_data["database"]}, {e}!'
-            )
+            logger.error(f"Error connecting to MySQL {self.connection_data['database']}, {e}!")
             result.error_message = str(e)
 
         if result.success and need_to_close:
@@ -252,9 +250,7 @@ class MySQLHandler(DatabaseHandler):
                 else:
                     response = Response(RESPONSE_TYPE.OK, affected_rows=cur.rowcount)
         except mysql.connector.Error as e:
-            logger.error(
-                f'Error running query: {query} on {self.connection_data["database"]}!'
-            )
+            logger.error(f"Error running query: {query} on {self.connection_data['database']}!")
             response = Response(RESPONSE_TYPE.ERROR, error_message=str(e))
             if connection is not None and connection.is_connected():
                 connection.rollback()