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

mindsdb/integrations/handlers/langchain_handler/tools.py

@@ -1,6 +1,5 @@
 import tiktoken
-
-from typing import Callable, Dict
+from typing import Callable
 
 from mindsdb_sql_parser import parse_sql
 from mindsdb_sql_parser.ast import Insert
@@ -13,21 +12,18 @@ from langchain.chains.llm import LLMChain
 from langchain.chains.combine_documents.stuff import StuffDocumentsChain
 from langchain.chains import ReduceDocumentsChain, MapReduceDocumentsChain
 
-from mindsdb.integrations.utilities.rag.rag_pipeline_builder import RAG
-from mindsdb.integrations.utilities.rag.settings import RAGPipelineModel, VectorStoreType, DEFAULT_COLLECTION_NAME
-from mindsdb.interfaces.skills.skill_tool import skill_tool, SkillType
-from mindsdb.interfaces.storage import db
+from mindsdb.interfaces.skills.skill_tool import skill_tool
 from mindsdb.utilities import log
 from langchain_core.prompts import PromptTemplate
 from langchain_core.tools import Tool
 from langchain_text_splitters import CharacterTextSplitter
 
 logger = log.getLogger(__name__)
-from mindsdb.interfaces.storage.db import KnowledgeBase
-from mindsdb.utilities import log
 
 # Individual tools
 # Note: all tools are defined in a closure to pass required args (apart from LLM input) through it, as custom tools don't allow custom field assignment.  # noqa
+
+
 def get_exec_call_tool(llm, executor, model_kwargs) -> Callable:
     def mdb_exec_call_tool(query: str) -> str:
         try:
@@ -50,6 +46,7 @@ def get_exec_call_tool(llm, executor, model_kwargs) -> Callable:
         return data
     return mdb_exec_call_tool
 
+
 def get_exec_metadata_tool(llm, executor, model_kwargs) -> Callable:
     def mdb_exec_metadata_call(query: str) -> str:
         try:
@@ -80,9 +77,9 @@ def get_exec_metadata_tool(llm, executor, model_kwargs) -> Callable:
                         data = f'Metadata for table {table_name}:\n'
                     fields = handler.get_columns(table_name).data_frame['Field'].to_list()
                     types = handler.get_columns(table_name).data_frame['Type'].to_list()
-                    data += f'List of columns and types:\n'
+                    data += 'List of columns and types:\n'
                     data += '\n'.join([f'\tColumn: `{field}`\tType: `{typ}`' for field, typ in zip(fields, types)])
-                except:
+                except BaseException:
                     data = f'Table {table_name} not found.'
         except Exception as e:
             data = f"mindsdb tool failed with error:\n{str(e)}"  # let the agent know
@@ -93,6 +90,7 @@ def get_exec_metadata_tool(llm, executor, model_kwargs) -> Callable:
         return data
     return mdb_exec_metadata_call
 
+
 def get_mdb_write_tool(executor) -> Callable:
     def mdb_write_call(query: str) -> str:
         try:
@@ -105,6 +103,7 @@ def get_mdb_write_tool(executor) -> Callable:
             return f"mindsdb write tool failed with error:\n{str(e)}"
     return mdb_write_call
 
+
 def _setup_standard_tools(tools, llm, model_kwargs):
     executor = skill_tool.get_command_executor()
 

mindsdb/integrations/handlers/leonardoai_handler/__init__.py

@@ -2,7 +2,7 @@ from mindsdb.integrations.libs.const import HANDLER_TYPE
 
 from .__about__ import __version__ as version, __description__ as description
 try:
-    from .leonardo_ai_handler import  LeonardoAIHandler as Handler
+    from .leonardo_ai_handler import LeonardoAIHandler as Handler
     import_error = None
 except Exception as e:
     Handler = None

mindsdb/integrations/handlers/lightwood_handler/functions.py

@@ -9,13 +9,12 @@ from pathlib import Path
 import lightwood
 import pandas as pd
 import requests
-from lightwood.api.types import JsonAI, ProblemDefinition
+from lightwood.api.types import JsonAI
 from pandas.core.frame import DataFrame
 
 import mindsdb.utilities.profiler as profiler
 from mindsdb.integrations.libs.const import PREDICTOR_STATUS
 from mindsdb.integrations.utilities.utils import format_exception_error
-from mindsdb.interfaces.model.functions import get_model_records
 from mindsdb.interfaces.storage import db
 from mindsdb.interfaces.storage.fs import RESOURCE_GROUP, FileStorage
 from mindsdb.interfaces.storage.json import get_json_storage
@@ -26,6 +25,7 @@ from .utils import brack_to_mod, rep_recur, unpack_jsonai_old_args
 
 logger = log.getLogger(__name__)
 
+
 def create_learn_mark():
     if os.name == 'posix':
         p = Path(tempfile.gettempdir()).joinpath('mindsdb/learn_processes/')

mindsdb/integrations/handlers/lightwood_handler/lightwood_handler.py

@@ -1,6 +1,5 @@
 import copy
 import json
-import sys
 from datetime import datetime
 from functools import lru_cache
 from typing import Dict, Optional

mindsdb/integrations/handlers/lightwood_handler/tests/test_lightwood_handler.py

@@ -1,3 +1,12 @@
+import mindsdb.interfaces.storage.db as db
+from mindsdb.integrations.libs.response import RESPONSE_TYPE
+from mindsdb.interfaces.model.model_controller import ModelController
+from mindsdb.interfaces.storage.fs import FsStore
+from mindsdb.integrations.handlers.lightwood_handler.lightwood_handler.lightwood_handler import LightwoodHandler
+from mindsdb.interfaces.database.integrations import integration_controller
+from mindsdb.integrations.utilities.test_utils import PG_HANDLER_NAME, PG_CONNECTION_DATA
+from mindsdb.utilities.config import Config
+from mindsdb.migrations import migrate
 import os
 import time
 import unittest
@@ -7,18 +16,9 @@ temp_dir = tempfile.mkdtemp(dir='/tmp/', prefix='lightwood_handler_test_')
 os.environ['MINDSDB_STORAGE_DIR'] = os.environ.get('MINDSDB_STORAGE_DIR', temp_dir)
 os.environ['MINDSDB_DB_CON'] = 'sqlite:///' + os.path.join(os.environ['MINDSDB_STORAGE_DIR'], 'mindsdb.sqlite3.db') + '?check_same_thread=False&timeout=30'
 
-from mindsdb.migrations import migrate
 migrate.migrate_to_head()
 
-from mindsdb.utilities.config import Config
-from mindsdb.integrations.utilities.test_utils import HandlerControllerMock, PG_HANDLER_NAME, PG_CONNECTION_DATA
-from mindsdb.interfaces.database.integrations import integration_controller
-from mindsdb.integrations.handlers.lightwood_handler.lightwood_handler.lightwood_handler import LightwoodHandler
 # from mindsdb.integrations.handlers.lightwood_handler.lightwood_handler.utils import load_predictor
-from mindsdb.interfaces.storage.fs import FsStore
-from mindsdb.interfaces.model.model_controller import ModelController
-from mindsdb.integrations.libs.response import RESPONSE_TYPE
-import mindsdb.interfaces.storage.db as db
 
 
 # TODO: drop all models and tables when closing tests
@@ -96,7 +96,7 @@ class LightwoodHandlerTest(unittest.TestCase):
         self.assertTrue(response.type == RESPONSE_TYPE.OK)
 
     def test_04_query_predictor_single_where_condition(self):
-        time.sleep(120) # TODO 
+        time.sleep(120)  # TODO
         query = f"""
             SELECT target
             from {self.test_model_1}
@@ -255,4 +255,4 @@ class LightwoodHandlerTest(unittest.TestCase):
 
 
 if __name__ == "__main__":
-    unittest.main(failfast=True)
+    unittest.main(failfast=True)

mindsdb/integrations/handlers/llama_index_handler/llama_index_handler.py

@@ -50,7 +50,7 @@ class LlamaIndexHandler(BaseMLEngine):
         # workaround to create llama model without input data
         if df is None or df.empty:
             df = pd.DataFrame([{"text": ""}])
-        
+
         args_reader = args.get("using", {}).get("reader", self.default_reader)
 
         if args_reader == "DFReader":
@@ -138,7 +138,7 @@ class LlamaIndexHandler(BaseMLEngine):
 
             if input_column is None:
                 raise Exception(
-                    f"`input_column` must be provided at model creation time or through USING clause when predicting. Please try again."
+                    "`input_column` must be provided at model creation time or through USING clause when predicting. Please try again."
                 )  # noqa
 
             if input_column not in df.columns:
@@ -151,7 +151,7 @@ class LlamaIndexHandler(BaseMLEngine):
         index_path = self.model_storage.folder_get("context")
         storage_context = StorageContext.from_defaults(persist_dir=index_path)
         self._get_service_context()
-       
+
         index = load_index_from_storage(
             storage_context
         )
@@ -182,7 +182,7 @@ class LlamaIndexHandler(BaseMLEngine):
             llm_kwargs["model_name"] = args["using"]["model_name"]
         if "max_tokens" in args["using"]:
             llm_kwargs["max_tokens"] = args["using"]["max_tokens"]
-        #only way this works is by sending the key through openai
+        # only way this works is by sending the key through openai
 
         openai.api_key = openai_api_key
         if Settings.llm is None:

mindsdb/integrations/handlers/llama_index_handler/settings.py

@@ -2,6 +2,7 @@ from typing import List, Optional
 from pydantic import BaseModel, field_validator, model_validator
 from pydantic_settings import BaseSettings
 
+
 class LlamaIndexConfig(BaseSettings):
     """
     Model for LlamaIndexHandler settings.
@@ -12,14 +13,15 @@ class LlamaIndexConfig(BaseSettings):
         default_reader (str): Default reader. Note this is custom data frame reader.
         supported_reader (List[str]): Supported readers.
     """
-    DEFAULT_INDEX_CLASS : str = "VectorStoreIndex"
-    SUPPORTED_INDEXES : List[str] = ["VectorStoreIndex"]
+    DEFAULT_INDEX_CLASS: str = "VectorStoreIndex"
+    SUPPORTED_INDEXES: List[str] = ["VectorStoreIndex"]
     DEFAULT_READER: str = "DFReader"
-    SUPPORTED_READERS : List[str] = ["DFReader", "SimpleWebPageReader"]
+    SUPPORTED_READERS: List[str] = ["DFReader", "SimpleWebPageReader"]
 
 
 llama_index_config = LlamaIndexConfig()
 
+
 class LlamaIndexModel(BaseModel):
     """
     Model for LlamaIndexHandler.
@@ -45,7 +47,7 @@ class LlamaIndexModel(BaseModel):
     def validate_reader(cls, value):
         if value not in llama_index_config.SUPPORTED_READERS:
             raise ValueError(f"Reader {value} is not supported.")
-        
+
         return value
 
     @field_validator('index_class')
@@ -53,13 +55,12 @@ class LlamaIndexModel(BaseModel):
     def validate_index_class(cls, value):
         if value not in llama_index_config.SUPPORTED_INDEXES:
             raise ValueError(f"Index class {value} is not supported.")
-        
+
         return value
-    
+
     @model_validator(mode='after')
     def validate_mode(self):
         if self.mode == "conversational" and not all([self.user_column, self.assistant_column]):
-            raise ValueError(f"Conversational mode requires user_column and assistant_column parameter")
-        
-        return self
+            raise ValueError("Conversational mode requires user_column and assistant_column parameter")
 
+        return self

mindsdb/integrations/handlers/materialize_handler/tests/test_materialize_handler.py

@@ -2,6 +2,7 @@ import unittest
 from mindsdb.integrations.handlers.materialize_handler.materialize_handler import MaterializeHandler
 from mindsdb.integrations.libs.response import RESPONSE_TYPE
 
+
 class materializeHandlerTest(unittest.TestCase):
     @classmethod
     def setUpClass(cls):
@@ -21,36 +22,33 @@ class materializeHandlerTest(unittest.TestCase):
 
     def test_1_connect(self):
         assert self.handler.connect()
-    
+
     def test_2_create_table(self):
         query = "CREATE Table IF NOT EXISTS Lover(name varchar(101));"
         result = self.handler.query(query)
-        assert result.type is not RESPONSE_TYPE.ERROR 
+        assert result.type is not RESPONSE_TYPE.ERROR
 
     def test_3_insert(self):
         query = "INSERT INTO LOVER VALUES('Shiv Shakti');"
         result = self.handler.query(query)
-        assert result.type is not RESPONSE_TYPE.ERROR 
+        assert result.type is not RESPONSE_TYPE.ERROR
 
     def test_4_native_query_select(self):
         query = "SELECT * FROM LOVER;"
         result = self.handler.query(query)
-        assert result.type is RESPONSE_TYPE.TABLE 
+        assert result.type is RESPONSE_TYPE.TABLE
 
     def test_5_get_tables(self):
         tables = self.handler.get_tables()
-        assert tables.type is  RESPONSE_TYPE.TABLE
+        assert tables.type is RESPONSE_TYPE.TABLE
 
     def test_6_get_columns(self):
         columns = self.handler.get_columns('LOVER')
-        
+
         query = "DROP Table IF  EXISTS Lover;"
-        result = self.handler.query(query)
+        self.handler.query(query)
         assert columns.type is not RESPONSE_TYPE.ERROR
 
 
 if __name__ == '__main__':
     unittest.main()
-
-
-    

mindsdb/integrations/handlers/matrixone_handler/matrixone_handler.py

@@ -18,6 +18,7 @@ from mindsdb.integrations.libs.response import (
 
 logger = log.getLogger(__name__)
 
+
 class MatrixOneHandler(DatabaseHandler):
     """
     This handler handles connection and execution of the MatrixOne statements.
@@ -25,7 +26,7 @@ class MatrixOneHandler(DatabaseHandler):
 
     name = 'matrixone'
 
-    def __init__(self, name,connection_data: Optional[dict], **kwargs):
+    def __init__(self, name, connection_data: Optional[dict], **kwargs):
         super().__init__(name)
         self.mysql_url = None
         self.parser = parse_sql
@@ -158,11 +159,10 @@ class MatrixOneHandler(DatabaseHandler):
         """
         q = f"SHOW COLUMNS FROM {table_name};"
         result = self.native_query(q)
-        df=result.data_frame
-        result.data_frame=df.rename(columns={
+        df = result.data_frame
+        result.data_frame = df.rename(columns={
             df.columns[0]: 'COLUMN_NAME',
             df.columns[1]: 'DATA TYPE'
         })
 
-
         return result

mindsdb/integrations/handlers/matrixone_handler/tests/test_matrixone_handler.py

@@ -19,38 +19,37 @@ class MatrixOneHandlerTest(unittest.TestCase):
         }
         cls.handler = MatrixOneHandler('test_mysql_handler', cls.kwargs)
 
-
     def test_0_connect(self):
         self.handler.connect()
 
     def test_1_drop_table(self):
         res = self.handler.query("DROP TABLE IF EXISTS PREM;")
-        assert res.type is  not RESPONSE_TYPE.ERROR
+        assert res.type is not RESPONSE_TYPE.ERROR
 
     def test_2_create_table(self):
         res = self.handler.query("CREATE TABLE IF NOT EXISTS PREM (Premi varchar(50));")
-        assert res.type is not  RESPONSE_TYPE.ERROR 
+        assert res.type is not RESPONSE_TYPE.ERROR
 
     def test_3_insert_table(self):
         res = self.handler.query("INSERT INTO PREM VALUES('Radha <3 Krishna');")
-        assert res.type is not  RESPONSE_TYPE.ERROR 
+        assert res.type is not RESPONSE_TYPE.ERROR
 
     def test_4_get_tables(self):
         tables = self.handler.get_tables()
-        assert tables.type is not  RESPONSE_TYPE.ERROR
+        assert tables.type is not RESPONSE_TYPE.ERROR
 
     def test_5_select_query(self):
         query = "SELECT * FROM PREM;"
         result = self.handler.native_query(query)
-        assert result.type is not  RESPONSE_TYPE.ERROR
-    
+        assert result.type is not RESPONSE_TYPE.ERROR
+
     def test_6_get_columns(self):
         result = self.handler.get_columns('PREM')
-        assert result.type is not  RESPONSE_TYPE.ERROR
+        assert result.type is not RESPONSE_TYPE.ERROR
 
     def test_7_check_connection(self):
         self.handler.check_connection()
 
 
 if __name__ == '__main__':
-    unittest.main()
+    unittest.main()

mindsdb/integrations/handlers/maxdb_handler/connection_args.py

@@ -4,31 +4,31 @@ from mindsdb.integrations.libs.const import HANDLER_CONNECTION_ARG_TYPE as ARG_T
 
 
 connection_args = OrderedDict(
-        host={
-            'type': ARG_TYPE.STR,
-            'description': 'The host name or IP address of the SAP MaxDB server.'
-        },
-        port={
-            'type': ARG_TYPE.INT,
-            'description': 'The TCP/IP port of the SAP MaxDB. Must be an integer.'
-        },
-        database={
-            'type': ARG_TYPE.STR,
-            'description': 'The database name to use when connecting with the SAP MaxDB server.'
-        },
-        jdbc_location={
-            'type': ARG_TYPE.STR,
-            'description': 'The location of the jar file which contains the JDBC class.'
-        },
-        user={
-            'type': ARG_TYPE.STR,
-            'description': 'The user name used to authenticate with the SAP MaxDB server.'
-        },
-        password={
-            'type': ARG_TYPE.PWD,
-            'description': 'The password to authenticate the user with the SAP MaxDB server.',
-            'secret': True
-        }
+    host={
+        'type': ARG_TYPE.STR,
+        'description': 'The host name or IP address of the SAP MaxDB server.'
+    },
+    port={
+        'type': ARG_TYPE.INT,
+        'description': 'The TCP/IP port of the SAP MaxDB. Must be an integer.'
+    },
+    database={
+        'type': ARG_TYPE.STR,
+        'description': 'The database name to use when connecting with the SAP MaxDB server.'
+    },
+    jdbc_location={
+        'type': ARG_TYPE.STR,
+        'description': 'The location of the jar file which contains the JDBC class.'
+    },
+    user={
+        'type': ARG_TYPE.STR,
+        'description': 'The user name used to authenticate with the SAP MaxDB server.'
+    },
+    password={
+        'type': ARG_TYPE.PWD,
+        'description': 'The password to authenticate the user with the SAP MaxDB server.',
+        'secret': True
+    }
 )
 
 

mindsdb/integrations/handlers/maxdb_handler/maxdb_handler.py

@@ -16,6 +16,7 @@ import jaydebeapi as jd
 
 logger = log.getLogger(__name__)
 
+
 class MaxDBHandler(DatabaseHandler):
     """
        This handler handles connection and execution of the SAP MaxDB  statements.

mindsdb/integrations/handlers/mediawiki_handler/mediawiki_handler.py

@@ -11,6 +11,7 @@ from mindsdb_sql_parser import parse_sql
 
 logger = log.getLogger(__name__)
 
+
 class MediaWikiHandler(APIHandler):
     """
     The MediaWiki handler implementation.
@@ -65,7 +66,7 @@ class MediaWikiHandler(APIHandler):
             self.connect()
             response.success = True
         except Exception as e:
-            logger.error(f'Error connecting to MediaWiki!')
+            logger.error('Error connecting to MediaWiki!')
             response.error_message = str(e)
 
         self.is_connected = response.success
@@ -84,4 +85,4 @@ class MediaWikiHandler(APIHandler):
             Request status
         """
         ast = parse_sql(query)
-        return self.query(ast)
+        return self.query(ast)

mindsdb/integrations/handlers/mediawiki_handler/mediawiki_tables.py

@@ -95,4 +95,4 @@ class PagesTable(APITable):
             except KeyError:
                 logger.debug(f"Error accessing '{attribute}' attribute. Skipping...")
 
-        return result
+        return result

mindsdb/integrations/handlers/mendeley_handler/__about__.py

@@ -6,4 +6,4 @@ __author__ = 'Christina Nikolovieni'
 __github__ = 'https://github.com/mindsdb/mindsdb'
 __pypi__ = 'https://pypi.org/project/mindsdb/'
 __license__ = 'MIT'
-__copyright__ = 'Copyright 2022- mindsdb'
+__copyright__ = 'Copyright 2022- mindsdb'

mindsdb/integrations/handlers/mendeley_handler/__init__.py

@@ -11,9 +11,9 @@ except Exception as e:
 title = 'Mendeley'
 name = 'mendeley'
 type = HANDLER_TYPE.DATA
-icon_path= 'icon.svg'
+icon_path = 'icon.svg'
 permanent = False
 
 __all__ = [
-    'Handler', 'version', 'name', 'type', 'title', 'description', 'import_error','icon_path'
+    'Handler', 'version', 'name', 'type', 'title', 'description', 'import_error', 'icon_path'
 ]