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

mindsdb/integrations/handlers/mendeley_handler/mendeley_tables.py

@@ -3,25 +3,25 @@ import pandas as pd
 from mindsdb.integrations.libs.api_handler import APITable
 from mindsdb.integrations.utilities.sql_utils import extract_comparison_conditions
 
+
 class CatalogSearchTable(APITable):
 
     def select(self, query: ast.Select) -> pd.DataFrame:
-
         """The select method implements the mappings from the ast.Select and calls the actual API through the call_mendeley_api.
         Firstly, it is used to put the parameters specified in the query in a dictionary, which is then used when calling the method call_mendeley_api.
         If no conditions are specified, an error is raised since the search cannot be conducted.
 
         Args:
-            query (ast.Select): query used to specify the wanted results 
+            query (ast.Select): query used to specify the wanted results
         Returns:
             result (DataFrame): the result of the query
         """
-       
+
         conditions = extract_comparison_conditions(query.where)
-        
-        params = {} 
 
-        #Since there are three different types of search, and each of them takes different parameters, we use the parameters that lead
+        params = {}
+
+        # Since there are three different types of search, and each of them takes different parameters, we use the parameters that lead
         # to the most specific results. For example, in the case of the user specifying the title and the doi of a document, priority is given to
         # the doi.
 
@@ -30,7 +30,7 @@ class CatalogSearchTable(APITable):
         else:
             params['limit'] = 30
 
-        for op,arg1,arg2 in conditions:
+        for op, arg1, arg2 in conditions:
 
             if arg1 in ['arxiv', 'doi', 'isbn', 'issn', 'pmid', 'scopus', 'filehash']:
 
@@ -39,8 +39,8 @@ class CatalogSearchTable(APITable):
                 params[arg1] = arg2
 
                 result = self.handler.call_mendeley_api(
-                method_name='identifier_search',
-                params=params)
+                    method_name='identifier_search',
+                    params=params)
 
                 break
 
@@ -50,52 +50,50 @@ class CatalogSearchTable(APITable):
                 params['id'] = arg2
 
                 result = self.handler.call_mendeley_api(
-                method_name='get',
-                params=params)
+                    method_name='get',
+                    params=params)
 
                 break
 
-            elif "title" or "author" or"source" or "abstract" or "min_year" or "max_year" or "open_access" or "view" in conditions:
+            elif "title" or "author" or "source" or "abstract" or "min_year" or "max_year" or "open_access" or "view" in conditions:
 
                 if arg1 == 'title':
                     if op != '=':
                         raise NotImplementedError
                     params['title'] = arg2
-                
+
                 elif arg1 == 'author':
                     if op != '=':
                         raise NotImplementedError
                     params['author'] = arg2
-                
+
                 elif arg1 == 'source':
                     if op != '=':
                         raise NotImplementedError
                     params['source'] = arg2
-                
+
                 elif arg1 == 'abstract':
                     if op != '=':
                         raise NotImplementedError
                     params['abstract'] = arg2
-                
+
                 elif arg1 == 'min_year':
                     params['min_year'] = arg2
-                
+
                 elif arg1 == 'max_year':
                     params['max_year'] = arg2
-                
+
                 elif arg1 == 'open_access':
                     if op != '=':
                         raise NotImplementedError
                     params['open_access'] = arg2
-                
-            
+
                 result = self.handler.call_mendeley_api(
-                method_name='advanced_search',
-                params=params)
-        
-        if conditions==[]:
+                    method_name='advanced_search',
+                    params=params)
+
+        if conditions == []:
             raise ValueError('Please give input for the search to be conducted.')
-        
 
         columns = []
 
@@ -107,10 +105,9 @@ class CatalogSearchTable(APITable):
                 columns.append(target.parts[-1])
             else:
                 raise ValueError(f"Unknown query target {type(target)}")
-        
 
         return result[columns]
-    
+
     def get_columns(self):
         """ get_columns method returns the columns returned by the API"""
         return [
@@ -130,5 +127,3 @@ class CatalogSearchTable(APITable):
             'link',
             'id'
         ]
-
-        

mindsdb/integrations/handlers/mendeley_handler/tests/test_mendeley_handler.py

@@ -3,13 +3,14 @@ import unittest
 from mindsdb.integrations.handlers.mendeley_handler.mendeley_handler import MendeleyHandler
 from mindsdb.api.executor.data_types.response_type import RESPONSE_TYPE
 
+
 class MendeleyHandlerTest(unittest.TestCase):
     @classmethod
     def setUpClass(cls):
         cls.kwargs = {
-            "connection_data":{"client_id":15253,"client_secret":"BxmSvbrRW5iYEIQR"}
+            "connection_data": {"client_id": 15253, "client_secret": "BxmSvbrRW5iYEIQR"}
         }
-        cls.handler = MendeleyHandler("test_mendeley_handler",**cls.kwargs)
+        cls.handler = MendeleyHandler("test_mendeley_handler", **cls.kwargs)
 
     def test_0_connect(self):
         self.handler.connect()
@@ -26,56 +27,56 @@ class MendeleyHandlerTest(unittest.TestCase):
         query = "SELECT * FROM catalog_search_data WHERE id='af1a0408-7409-3a8b-ad91-8accd4f8849a'"
         result = self.handler.native_query(query)
         assert result.type is RESPONSE_TYPE.TABLE
-    
+
     def test_4_select(self):
         query = "SELECT * FROM catalog_search_data WHERE title='The American Mineralogist crystal structure database'"
         result = self.handler.native_query(query)
         assert result.type is RESPONSE_TYPE.TABLE
-    
+
     def test_5_select(self):
         query = "SELECT * FROM catalog_search_data WHERE id='8e86b541-84fd-30ef-9eed-e8c9af847ca3' AND doi='10.1093/ajcn/77.1.71'"
         result = self.handler.native_query(query)
         assert result.type is RESPONSE_TYPE.TABLE
-    
+
     def test_6_select(self):
         query = "SELECT * FROM catalog_search_data WHERE issn='15570878'"
         result = self.handler.native_query(query)
         assert result.type is RESPONSE_TYPE.TABLE
-    
+
     def test_7_select(self):
         query = "SELECT * FROM catalog_search_data WHERE source='American Journal of Clinical Nutrition'"
         result = self.handler.native_query(query)
         assert result.type is RESPONSE_TYPE.TABLE
-    
+
     def test_8_select(self):
         query = "SELECT * FROM catalog_search_data WHERE source='American Journal of Clinical Nutrition'AND id='4eeda257-8db4-3dad-80c8-6912356d3887'"
         result = self.handler.native_query(query)
         assert result.type is RESPONSE_TYPE.TABLE
-    
+
     def test_9_select(self):
         query = "SELECT * FROM catalog_search_data WHERE source='American Journal of Clinical Nutrition'AND max_year='2020'"
         result = self.handler.native_query(query)
         assert result.type is RESPONSE_TYPE.TABLE
-    
+
     def test_10_call_mendeley_api_invalid_method_name(self):
         with self.assertRaises(NotImplementedError):
-            res = self.handler.call_mendeley_api("method1",None)
+            self.handler.call_mendeley_api("method1", None)
 
     def test_11_select_invalid_condition_name(self):
         with self.assertRaises(NotImplementedError):
             query = "SELECT * FROM catalog_search_data WHERE name='American Journal of Clinical Nutrition'"
-            result = self.handler.native_query(query)
+            self.handler.native_query(query)
 
     def test_12_select_invalid_operator(self):
         with self.assertRaises(NotImplementedError):
             query = "SELECT * FROM catalog_search_data WHERE source>'American Journal of Clinical Nutrition'AND max_year='2020' "
-            result = self.handler.native_query(query)
-    
+            self.handler.native_query(query)
+
     def test_13_select_invalid_column_name(self):
         with self.assertRaises(KeyError):
             query = "SELECT name FROM catalog_search_data WHERE source='American Journal of Clinical Nutrition'AND max_year='2020' "
-            result = self.handler.native_query(query)
-    
+            self.handler.native_query(query)
+
     def test_14_get_columns(self):
         columns = self.handler.catalog_search_data.get_columns()
 
@@ -98,11 +99,12 @@ class MendeleyHandlerTest(unittest.TestCase):
         ]
 
         self.assertListEqual(columns, expected_columns)
-    
+
     def test_15_select_invalid_condition_name(self):
         with self.assertRaises(ValueError):
             query = "SELECT * FROM catalog_search_data"
-            result = self.handler.native_query(query)
+            self.handler.native_query(query)
+
 
 if __name__ == "__main__":
     unittest.main()

mindsdb/integrations/handlers/merlion_handler/merlion_handler.py

@@ -14,6 +14,7 @@ from .adapters import BaseMerlionForecastAdapter, DefaultForecasterAdapter, Merl
 
 logger = log.getLogger(__name__)
 
+
 class DetectorModelType(Enum):
     default = DefaultDetectorAdapter
     isolation = IsolationForestDetectorAdapter
@@ -36,7 +37,7 @@ class TaskType(Enum):
 def is_invalid_type(name: str, type_class: Enum) -> bool:
     if name is None:
         return True
-    return not name in type_class._member_names_
+    return name not in type_class._member_names_
 
 
 def enum_to_str(type_class: Enum) -> str:
@@ -194,12 +195,12 @@ class MerlionHandler(BaseMLEngine):
         # check task_type
         try:
             task_enum = TaskType[task]
-        except Exception as e:
+        except Exception:
             raise Exception("wrong using.task: " + task + ", valid options: " + enum_to_str(TaskType))
         # check and get model class
         try:
             adapter_class = task_enum.value[model_type].value
         except Exception as e:
-            raise Exception("Wrong using.model_type: " + model_type + ", valid options: " +
-                            enum_to_str(task_enum.value) + ", " + str(e))
+            raise Exception("Wrong using.model_type: " + model_type + ", valid options: "
+                            + enum_to_str(task_enum.value) + ", " + str(e))
         return adapter_class

mindsdb/integrations/handlers/minds_endpoint_handler/__init__.py

@@ -1,10 +1,10 @@
+from .__about__ import __version__ as version
+from .__about__ import __description__ as description
 from mindsdb.integrations.libs.const import HANDLER_TYPE
 from mindsdb.utilities import log
 
 logger = log.getLogger(__name__)
 
-from .__about__ import __description__ as description
-from .__about__ import __version__ as version
 
 try:
     from .minds_endpoint_handler import MindsEndpointHandler as Handler
@@ -20,4 +20,4 @@ type = HANDLER_TYPE.ML
 icon_path = 'icon.svg'
 permanent = False
 
-__all__ = ["Handler", "version", "name", "type", "title", "description", "import_error", "icon_path"]
+__all__ = ["Handler", "version", "name", "type", "title", "description", "import_error", "icon_path"]

mindsdb/integrations/handlers/mlflow_handler/mlflow_handler.py

@@ -18,66 +18,88 @@ class MLflowHandler(BaseMLEngine):
         1. Run `mlflow server -p 5001 --backend-store-uri sqlite:////path/to/mlflow.db --default-artifact-root ./artifacts --host 0.0.0.0`
         2. Run `mlflow models serve --model-uri ./model_path`
         3. Run MindsDB
-    
+
     Note: above, `artifacts` is a folder to store artifacts for new experiments that do not specify an artifact store.
     """  # noqa
 
-    name = 'mlflow'
+    name = "mlflow"
 
-    def create(self, target: str, df: Optional[pd.DataFrame] = None, args: Optional[Dict] = None) -> None:
-        args = args['using']  # ignore the rest of the problem definition
-        connection = MlflowClient(args['mlflow_server_url'], args['mlflow_server_path'])
-        model_name = args['model_name']
+    def create(
+        self,
+        target: str,
+        df: Optional[pd.DataFrame] = None,
+        args: Optional[Dict] = None,
+    ) -> None:
+        args = args["using"]  # ignore the rest of the problem definition
+        connection = MlflowClient(args["mlflow_server_url"], args["mlflow_server_path"])
+        model_name = args["model_name"]
         mlflow_models = [model.name for model in connection.search_registered_models()]
 
         if model_name not in mlflow_models:
-            raise Exception(f"Error: model '{model_name}' not found in mlflow. Check serving and try again.")
+            raise Exception(
+                f"Error: model '{model_name}' not found in mlflow. Check serving and try again."
+            )
 
-        args['target'] = target
-        self._check_model_url(args['predict_url'])
-        self.model_storage.json_set('args', args)
+        args["target"] = target
+        self._check_model_url(args["predict_url"])
+        self.model_storage.json_set("args", args)
 
     def predict(self, df, args=None):
-        args = self.model_storage.json_get('args')  # override any incoming args for now
-        self._check_model_url(args['predict_url'])
-        resp = requests.post(args['predict_url'],
-                             data=df.to_json(orient='records'),
-                             headers={'content-type': 'application/json; format=pandas-records'})
+        args = self.model_storage.json_get("args")  # override any incoming args for now
+        self._check_model_url(args["predict_url"])
+        resp = requests.post(
+            args["predict_url"],
+            data=df.to_json(orient="records"),
+            headers={"content-type": "application/json; format=pandas-records"},
+        )
         answer = resp.json()
-        predictions = pd.DataFrame({args['target']: answer})
+        predictions = pd.DataFrame({args["target"]: answer})
         return predictions
 
     def describe(self, key: Optional[str] = None) -> pd.DataFrame:
-        if key == 'info':
-            args = self.model_storage.json_get('args')
-            connection = MlflowClient(args['mlflow_server_url'], args['self.mlflow_server_path'])
-            models = {model.name: model for model in connection.search_registered_models()}
+        if key == "info":
+            args = self.model_storage.json_get("args")
+            connection = MlflowClient(
+                args["mlflow_server_url"], args["self.mlflow_server_path"]
+            )
+            models = {
+                model.name: model for model in connection.search_registered_models()
+            }
             model = models[key]
             latest_version = model.latest_versions[-1]
             description = {
-                'NAME': [model.name],
-                'USER_DESCRIPTION': [model.description],
-                'LAST_STATUS': [latest_version.status],
-                'CREATED_AT': [datetime.fromtimestamp(model.creation_timestamp//1000).strftime("%m/%d/%Y, %H:%M:%S")],
-                'LAST_UPDATED': [datetime.fromtimestamp(model.last_updated_timestamp//1000).strftime("%m/%d/%Y, %H:%M:%S")],
-                'TAGS': [model.tags],
-                'LAST_RUN_ID': [latest_version.run_id],
-                'LAST_SOURCE_PATH': [latest_version.source],
-                'LAST_USER_ID': [latest_version.user_id],
-                'LAST_VERSION': [latest_version.version],
+                "NAME": [model.name],
+                "USER_DESCRIPTION": [model.description],
+                "LAST_STATUS": [latest_version.status],
+                "CREATED_AT": [
+                    datetime.fromtimestamp(model.creation_timestamp // 1000).strftime(
+                        "%m/%d/%Y, %H:%M:%S"
+                    )
+                ],
+                "LAST_UPDATED": [
+                    datetime.fromtimestamp(
+                        model.last_updated_timestamp // 1000
+                    ).strftime("%m/%d/%Y, %H:%M:%S")
+                ],
+                "TAGS": [model.tags],
+                "LAST_RUN_ID": [latest_version.run_id],
+                "LAST_SOURCE_PATH": [latest_version.source],
+                "LAST_USER_ID": [latest_version.user_id],
+                "LAST_VERSION": [latest_version.version],
             }
             return pd.DataFrame.from_dict(description)
         else:
-            tables = ['info']
-            return pd.DataFrame(tables, columns=['tables'])
-
+            tables = ["info"]
+            return pd.DataFrame(tables, columns=["tables"])
 
     @staticmethod
     def _check_model_url(url):
-        """ try post without data, check status code not in (not_found, method_not_allowed) """
+        """try post without data, check status code not in (not_found, method_not_allowed)"""
         try:
             resp = requests.post(url)
             if resp.status_code in (404, 405):
-                raise Exception(f'Model url is incorrect, status_code: {resp.status_code}')
+                raise Exception(
+                    f"Model url is incorrect, status_code: {resp.status_code}"
+                )
         except requests.RequestException as e:
-            raise Exception(f'Model url is incorrect: {str(e)}')
+            raise Exception(f"Model url is incorrect: {str(e)}")

mindsdb/integrations/handlers/monetdb_handler/__about__.py

@@ -1,9 +1,9 @@
-__title__ = 'MindsDB MonetDB handler'
-__package_name__ = 'mindsdb_monetdb_handler'
-__version__ = '0.0.1'
+__title__ = "MindsDB MonetDB handler"
+__package_name__ = "mindsdb_monetdb_handler"
+__version__ = "0.0.1"
 __description__ = "MindsDB handler for MonetDB"
-__author__ = 'Parthiv Makwana'
-__github__ = 'https://github.com/mindsdb/mindsdb'
-__pypi__ = 'https://pypi.org/project/mindsdb/'
-__license__ = 'MIT'
-__copyright__ = 'Copyright 2022- mindsdb'
+__author__ = "Parthiv Makwana"
+__github__ = "https://github.com/mindsdb/mindsdb"
+__pypi__ = "https://pypi.org/project/mindsdb/"
+__license__ = "MIT"
+__copyright__ = "Copyright 2022- mindsdb"

mindsdb/integrations/handlers/monetdb_handler/__init__.py

@@ -2,19 +2,29 @@ from mindsdb.integrations.libs.const import HANDLER_TYPE
 
 from .__about__ import __version__ as version, __description__ as description
 from .connection_args import connection_args, connection_args_example
+
 try:
     from .monetdb_handler import MonetDBHandler as Handler
+
     import_error = None
 except Exception as e:
     Handler = None
     import_error = e
 
-title = 'MonetDB'
-name = 'monetdb'
+title = "MonetDB"
+name = "monetdb"
 type = HANDLER_TYPE.DATA
-icon_path = 'icon.svg'
+icon_path = "icon.svg"
 
 __all__ = [
-    'Handler', 'version', 'name', 'type', 'title', 'description',
-    'connection_args', 'connection_args_example', 'import_error', 'icon_path'
+    "Handler",
+    "version",
+    "name",
+    "type",
+    "title",
+    "description",
+    "connection_args",
+    "connection_args_example",
+    "import_error",
+    "icon_path",
 ]

mindsdb/integrations/handlers/monetdb_handler/connection_args.py

@@ -5,40 +5,39 @@ 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 MonetDB server/database.'
+        "type": ARG_TYPE.STR,
+        "description": "The host name or IP address of the MonetDB server/database.",
     },
     database={
-        'type': ARG_TYPE.STR,
-        'description': """
+        "type": ARG_TYPE.STR,
+        "description": """
             The database name to use when connecting with the MonetDB server.
-        """
+        """,
     },
     user={
-        'type': ARG_TYPE.STR,
-        'description': 'The user name used to authenticate with the MonetDB server.'
+        "type": ARG_TYPE.STR,
+        "description": "The user name used to authenticate with the MonetDB server.",
     },
     password={
-        'type': ARG_TYPE.PWD,
-        'description': 'The password to authenticate the user with the MonetDB server.',
-        'secret': True
+        "type": ARG_TYPE.PWD,
+        "description": "The password to authenticate the user with the MonetDB server.",
+        "secret": True,
     },
     port={
-        'type': ARG_TYPE.INT,
-        'description': 'Specify port to connect MonetDB through TCP/IP'
+        "type": ARG_TYPE.INT,
+        "description": "Specify port to connect MonetDB through TCP/IP",
     },
     schema_name={
-        'type': ARG_TYPE.STR,
-        'description': 'Specify the schema name for Listing Table '
+        "type": ARG_TYPE.STR,
+        "description": "Specify the schema name for Listing Table ",
     },
-
 )
 
 connection_args_example = OrderedDict(
-    host='127.0.0.1',
+    host="127.0.0.1",
     port=50000,
-    password='monetdb',
-    user='monetdb',
+    password="monetdb",
+    user="monetdb",
     schemaName="sys",
     database="demo",
 )