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

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'
 ]

mindsdb/integrations/handlers/mendeley_handler/mendeley_handler.py

@@ -1,23 +1,21 @@
 from mindsdb_sql_parser import parse_sql
 import pandas as pd
 from mendeley import Mendeley
-from mindsdb.integrations.libs.api_handler import APIHandler, FuncParser
+from mindsdb.integrations.libs.api_handler import APIHandler
 from mendeley.session import MendeleySession
-from mindsdb.integrations.handlers.mendeley_handler.mendeley_tables import CatalogSearchTable 
+from mindsdb.integrations.handlers.mendeley_handler.mendeley_tables import CatalogSearchTable
 from mindsdb.utilities import log
 from typing import Dict
 from mindsdb.integrations.libs.response import (
-    HandlerStatusResponse as StatusResponse,
-    HandlerResponse as Response,
-    RESPONSE_TYPE
+    HandlerStatusResponse as StatusResponse
 )
 
 logger = log.getLogger(__name__)
 
-class MendeleyHandler(APIHandler): 
 
-    def __init__(self, name, **kwargs): 
+class MendeleyHandler(APIHandler):
 
+    def __init__(self, name, **kwargs):
         """ constructor
         Args:
             name (str): the handler name
@@ -25,16 +23,16 @@ class MendeleyHandler(APIHandler):
         super().__init__(name)
 
         self.connection_args = kwargs.get('connection_data', {})
-        
+
         self.client_id = self.connection_args.get('client_id', None)
         self.client_secret = self.connection_args.get('client_secret', None)
         self.session = self.connect()
 
         self.session = None
         self.is_connected = False
-    
+
         catalog_search_data = CatalogSearchTable(self)
-        self.catalog_search_data = catalog_search_data 
+        self.catalog_search_data = catalog_search_data
         self._register_table('catalog_search_data', catalog_search_data)
 
     def connect(self) -> MendeleySession:
@@ -47,7 +45,7 @@ class MendeleyHandler(APIHandler):
         Returns:
         HandlerStatusResponse """
 
-        if self.is_connected == True:
+        if self.is_connected:
             return self.session
 
         mendeley = Mendeley(self.client_id, self.client_secret)
@@ -56,9 +54,8 @@ class MendeleyHandler(APIHandler):
 
         self.is_connected = True
         return self.session
-    
-    def check_connection(self) -> StatusResponse:
 
+    def check_connection(self) -> StatusResponse:
         """ The check_connection method checks the connection to the handler
         Returns:
             HandlerStatusResponse
@@ -77,7 +74,6 @@ class MendeleyHandler(APIHandler):
         return response
 
     def native_query(self, query_string: str):
-        
         """The native_query method receives raw query and acts upon it.
             Args:
                 query_string (str): query in native format
@@ -86,9 +82,9 @@ class MendeleyHandler(APIHandler):
         """
         ast = parse_sql(query_string)
         return self.query(ast)
-    
-    def get_authors(self,data):
-        """The get_authors method receives the data - a specific document returned by the API, gets the names of the authors 
+
+    def get_authors(self, data):
+        """The get_authors method receives the data - a specific document returned by the API, gets the names of the authors
             and combines them in a string, so as to allow the use of DataFrame.
             Args:
                 data (CatalogDocument): document returned by API
@@ -97,18 +93,18 @@ class MendeleyHandler(APIHandler):
         """
         authors = ""
         sum = 0
-        if data.authors!=None:
+        if data.authors is not None:
             for x in data.authors:
-                if sum + 1 == len(data.authors) and x.first_name!=None and x.last_name!=None  :
+                if sum + 1 == len(data.authors) and x.first_name is not None and x.last_name is not None:
                     authors = authors + x.first_name + " " + x.last_name
                 else:
-                    if x.first_name!=None and x.last_name!=None:
+                    if x.first_name is not None and x.last_name is not None:
                         authors = authors + x.first_name + " " + x.last_name + ", "
                         sum = sum + 1
         return authors
 
-    def get_keywords(self,data):
-        """The get_keywords method receives the data-a specific document returned by the API, gets the specified keywords 
+    def get_keywords(self, data):
+        """The get_keywords method receives the data-a specific document returned by the API, gets the specified keywords
             and combines them in a string, so as to allow the use of DataFrame.
             Args:
                 data (CatalogDocument) : document returned by the API
@@ -117,18 +113,17 @@ class MendeleyHandler(APIHandler):
         """
         keywords = ""
         sum = 0
-        if data.keywords!=None:
+        if data.keywords is not None:
             for x in data.keywords:
                 if sum + 1 == len(data.keywords):
-                    keywords = keywords  + x + " "
+                    keywords = keywords + x + " "
                 else:
-                    if x!=None :
+                    if x is not None:
                         keywords = keywords + x + ", "
                         sum = sum + 1
         return keywords
-    
-    def create_dict(self,data):
 
+    def create_dict(self, data):
         """The create_dict method receives the data-a specific document returned by the API, gets the resources-fields of the document,
           as specified in Mendley documentation, and puts them in a dictionary.
 
@@ -142,7 +137,7 @@ class MendeleyHandler(APIHandler):
         dict["type"] = data.type
         dict["source"] = data.source
         dict["year"] = data.year
-        if data.identifiers!=None:
+        if data.identifiers is not None:
             dict["pmid"] = data.identifiers.get("pmid")
             dict["sgr"] = data.identifiers.get("sgr")
             dict["issn"] = data.identifiers.get("issn")
@@ -150,16 +145,15 @@ class MendeleyHandler(APIHandler):
             dict["doi"] = data.identifiers.get("doi")
             dict["pui"] = data.identifiers.get("pui")
         dict["authors"] = self.get_authors(data)
-        if data.keywords!=None:
+        if data.keywords is not None:
             dict["keywords"] = self.get_keywords(data)
         else:
             dict["keywords"] = None
         dict["link"] = data.link
         dict["id"] = data.id
         return dict
-    
+
     def call_mendeley_api(self, method_name: str, params: Dict) -> pd.DataFrame:
-        
         """The method call_mendeley_api is used to communicate with Mendeley. Depending on the method used there are three different types
         of search conducted.
         The advanced_search results in a CatalogSearch resource, which, depending on the parameters used, could either be a number of different documents (CatalogDocument),
@@ -174,28 +168,28 @@ class MendeleyHandler(APIHandler):
             DataFrame
         """
 
-        self.session= self.connect()
+        self.session = self.connect()
 
         if method_name == 'advanced_search':
             search_params = {
-            'title': params.get("title"),
-            'author': params.get("author"),
-            'source': params.get("source"),
-            'abstract': params.get("abstract"),
-            'min_year': params.get("min_year"),
-            'max_year': params.get("max_year"),
-            'open_access': params.get("open_access")
+                'title': params.get("title"),
+                'author': params.get("author"),
+                'source': params.get("source"),
+                'abstract': params.get("abstract"),
+                'min_year': params.get("min_year"),
+                'max_year': params.get("max_year"),
+                'open_access': params.get("open_access")
             }
             data = self.session.catalog.advanced_search(**search_params)
             sum = 0
             df = pd.DataFrame()
             for x in data.list(page_size=params["limit"]).items:
-                    if sum == 0:
-                        df = pd.DataFrame(self.create_dict(x),index=[0])
-                        sum += 1
-                    else : 
-                        df = df.append(self.create_dict(x),ignore_index = True)
-                        sum += 1
+                if sum == 0:
+                    df = pd.DataFrame(self.create_dict(x), index=[0])
+                    sum += 1
+                else:
+                    df = df.append(self.create_dict(x), ignore_index=True)
+                    sum += 1
             if df.empty:
                 raise NotImplementedError(('Insufficient or wrong input given'))
             else:
@@ -203,23 +197,21 @@ class MendeleyHandler(APIHandler):
 
         elif method_name == 'identifier_search':
             search_params = {
-            'arxiv': params.get("arxiv"),
-            'doi': params.get("doi"),
-            'isbn': params.get("isbn"),
-            'issn': params.get("issn"),
-            'pmid': params.get("pmid"),
-            'scopus': params.get("scopus"),
-            'filehash': params.get("filehash")
+                'arxiv': params.get("arxiv"),
+                'doi': params.get("doi"),
+                'isbn': params.get("isbn"),
+                'issn': params.get("issn"),
+                'pmid': params.get("pmid"),
+                'scopus': params.get("scopus"),
+                'filehash': params.get("filehash")
             }
             data = self.session.catalog.by_identifier(**search_params)
-            df = pd.DataFrame(self.create_dict(data),index=[0])
+            df = pd.DataFrame(self.create_dict(data), index=[0])
             return df
 
         elif method_name == 'get':
             data = self.session.catalog.get(params.get("id"))
-            df = pd.DataFrame(self.create_dict(data),index=[0])
+            df = pd.DataFrame(self.create_dict(data), index=[0])
             return df
 
         raise NotImplementedError('Method name {} not supported by Mendeley API Handler'.format(method_name))
-
-